1 //===-- Verifier.cpp - Implement the Module Verifier -----------------------==// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the function verifier interface, that can be used for some 11 // sanity checking of input to the system. 12 // 13 // Note that this does not provide full `Java style' security and verifications, 14 // instead it just tries to ensure that code is well-formed. 15 // 16 // * Both of a binary operator's parameters are of the same type 17 // * Verify that the indices of mem access instructions match other operands 18 // * Verify that arithmetic and other things are only performed on first-class 19 // types. Verify that shifts & logicals only happen on integrals f.e. 20 // * All of the constants in a switch statement are of the correct type 21 // * The code is in valid SSA form 22 // * It should be illegal to put a label into any other type (like a structure) 23 // or to return one. [except constant arrays!] 24 // * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad 25 // * PHI nodes must have an entry for each predecessor, with no extras. 26 // * PHI nodes must be the first thing in a basic block, all grouped together 27 // * PHI nodes must have at least one entry 28 // * All basic blocks should only end with terminator insts, not contain them 29 // * The entry node to a function must not have predecessors 30 // * All Instructions must be embedded into a basic block 31 // * Functions cannot take a void-typed parameter 32 // * Verify that a function's argument list agrees with it's declared type. 33 // * It is illegal to specify a name for a void value. 34 // * It is illegal to have a internal global value with no initializer 35 // * It is illegal to have a ret instruction that returns a value that does not 36 // agree with the function return value type. 37 // * Function call argument types match the function prototype 38 // * A landing pad is defined by a landingpad instruction, and can be jumped to 39 // only by the unwind edge of an invoke instruction. 40 // * A landingpad instruction must be the first non-PHI instruction in the 41 // block. 42 // * All landingpad instructions must use the same personality function with 43 // the same function. 44 // * All other things that are tested by asserts spread about the code... 45 // 46 //===----------------------------------------------------------------------===// 47 48 #include "llvm/IR/Verifier.h" 49 #include "llvm/ADT/STLExtras.h" 50 #include "llvm/ADT/SetVector.h" 51 #include "llvm/ADT/SmallPtrSet.h" 52 #include "llvm/ADT/SmallVector.h" 53 #include "llvm/ADT/StringExtras.h" 54 #include "llvm/IR/CFG.h" 55 #include "llvm/IR/CallSite.h" 56 #include "llvm/IR/CallingConv.h" 57 #include "llvm/IR/ConstantRange.h" 58 #include "llvm/IR/Constants.h" 59 #include "llvm/IR/DataLayout.h" 60 #include "llvm/IR/DebugInfo.h" 61 #include "llvm/IR/DerivedTypes.h" 62 #include "llvm/IR/Dominators.h" 63 #include "llvm/IR/InlineAsm.h" 64 #include "llvm/IR/InstIterator.h" 65 #include "llvm/IR/InstVisitor.h" 66 #include "llvm/IR/IntrinsicInst.h" 67 #include "llvm/IR/LLVMContext.h" 68 #include "llvm/IR/Metadata.h" 69 #include "llvm/IR/Module.h" 70 #include "llvm/IR/PassManager.h" 71 #include "llvm/IR/Statepoint.h" 72 #include "llvm/Pass.h" 73 #include "llvm/Support/CommandLine.h" 74 #include "llvm/Support/Debug.h" 75 #include "llvm/Support/ErrorHandling.h" 76 #include "llvm/Support/raw_ostream.h" 77 #include <algorithm> 78 #include <cstdarg> 79 using namespace llvm; 80 81 static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true)); 82 83 namespace { 84 struct VerifierSupport { 85 raw_ostream &OS; 86 const Module *M; 87 88 /// \brief Track the brokenness of the module while recursively visiting. 89 bool Broken; 90 91 explicit VerifierSupport(raw_ostream &OS) 92 : OS(OS), M(nullptr), Broken(false) {} 93 94 private: 95 void Write(const Value *V) { 96 if (!V) 97 return; 98 if (isa<Instruction>(V)) { 99 OS << *V << '\n'; 100 } else { 101 V->printAsOperand(OS, true, M); 102 OS << '\n'; 103 } 104 } 105 106 void Write(const Metadata *MD) { 107 if (!MD) 108 return; 109 MD->print(OS, M); 110 OS << '\n'; 111 } 112 113 template <class T> void Write(const MDTupleTypedArrayWrapper<T> &MD) { 114 Write(MD.get()); 115 } 116 117 void Write(const NamedMDNode *NMD) { 118 if (!NMD) 119 return; 120 NMD->print(OS); 121 OS << '\n'; 122 } 123 124 void Write(Type *T) { 125 if (!T) 126 return; 127 OS << ' ' << *T; 128 } 129 130 void Write(const Comdat *C) { 131 if (!C) 132 return; 133 OS << *C; 134 } 135 136 template <typename T1, typename... Ts> 137 void WriteTs(const T1 &V1, const Ts &... Vs) { 138 Write(V1); 139 WriteTs(Vs...); 140 } 141 142 template <typename... Ts> void WriteTs() {} 143 144 public: 145 /// \brief A check failed, so printout out the condition and the message. 146 /// 147 /// This provides a nice place to put a breakpoint if you want to see why 148 /// something is not correct. 149 void CheckFailed(const Twine &Message) { 150 OS << Message << '\n'; 151 Broken = true; 152 } 153 154 /// \brief A check failed (with values to print). 155 /// 156 /// This calls the Message-only version so that the above is easier to set a 157 /// breakpoint on. 158 template <typename T1, typename... Ts> 159 void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) { 160 CheckFailed(Message); 161 WriteTs(V1, Vs...); 162 } 163 }; 164 165 class Verifier : public InstVisitor<Verifier>, VerifierSupport { 166 friend class InstVisitor<Verifier>; 167 168 LLVMContext *Context; 169 DominatorTree DT; 170 171 /// \brief When verifying a basic block, keep track of all of the 172 /// instructions we have seen so far. 173 /// 174 /// This allows us to do efficient dominance checks for the case when an 175 /// instruction has an operand that is an instruction in the same block. 176 SmallPtrSet<Instruction *, 16> InstsInThisBlock; 177 178 /// \brief Keep track of the metadata nodes that have been checked already. 179 SmallPtrSet<const Metadata *, 32> MDNodes; 180 181 /// \brief Track unresolved string-based type references. 182 SmallDenseMap<const MDString *, const MDNode *, 32> UnresolvedTypeRefs; 183 184 /// \brief The personality function referenced by the LandingPadInsts. 185 /// All LandingPadInsts within the same function must use the same 186 /// personality function. 187 const Value *PersonalityFn; 188 189 /// \brief Whether we've seen a call to @llvm.frameescape in this function 190 /// already. 191 bool SawFrameEscape; 192 193 /// Stores the count of how many objects were passed to llvm.frameescape for a 194 /// given function and the largest index passed to llvm.framerecover. 195 DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo; 196 197 public: 198 explicit Verifier(raw_ostream &OS) 199 : VerifierSupport(OS), Context(nullptr), PersonalityFn(nullptr), 200 SawFrameEscape(false) {} 201 202 bool verify(const Function &F) { 203 M = F.getParent(); 204 Context = &M->getContext(); 205 206 // First ensure the function is well-enough formed to compute dominance 207 // information. 208 if (F.empty()) { 209 OS << "Function '" << F.getName() 210 << "' does not contain an entry block!\n"; 211 return false; 212 } 213 for (Function::const_iterator I = F.begin(), E = F.end(); I != E; ++I) { 214 if (I->empty() || !I->back().isTerminator()) { 215 OS << "Basic Block in function '" << F.getName() 216 << "' does not have terminator!\n"; 217 I->printAsOperand(OS, true); 218 OS << "\n"; 219 return false; 220 } 221 } 222 223 // Now directly compute a dominance tree. We don't rely on the pass 224 // manager to provide this as it isolates us from a potentially 225 // out-of-date dominator tree and makes it significantly more complex to 226 // run this code outside of a pass manager. 227 // FIXME: It's really gross that we have to cast away constness here. 228 DT.recalculate(const_cast<Function &>(F)); 229 230 Broken = false; 231 // FIXME: We strip const here because the inst visitor strips const. 232 visit(const_cast<Function &>(F)); 233 InstsInThisBlock.clear(); 234 PersonalityFn = nullptr; 235 SawFrameEscape = false; 236 237 return !Broken; 238 } 239 240 bool verify(const Module &M) { 241 this->M = &M; 242 Context = &M.getContext(); 243 Broken = false; 244 245 // Scan through, checking all of the external function's linkage now... 246 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 247 visitGlobalValue(*I); 248 249 // Check to make sure function prototypes are okay. 250 if (I->isDeclaration()) 251 visitFunction(*I); 252 } 253 254 // Now that we've visited every function, verify that we never asked to 255 // recover a frame index that wasn't escaped. 256 verifyFrameRecoverIndices(); 257 258 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 259 I != E; ++I) 260 visitGlobalVariable(*I); 261 262 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 263 I != E; ++I) 264 visitGlobalAlias(*I); 265 266 for (Module::const_named_metadata_iterator I = M.named_metadata_begin(), 267 E = M.named_metadata_end(); 268 I != E; ++I) 269 visitNamedMDNode(*I); 270 271 for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable()) 272 visitComdat(SMEC.getValue()); 273 274 visitModuleFlags(M); 275 visitModuleIdents(M); 276 277 // Verify type referneces last. 278 verifyTypeRefs(); 279 280 return !Broken; 281 } 282 283 private: 284 // Verification methods... 285 void visitGlobalValue(const GlobalValue &GV); 286 void visitGlobalVariable(const GlobalVariable &GV); 287 void visitGlobalAlias(const GlobalAlias &GA); 288 void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C); 289 void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited, 290 const GlobalAlias &A, const Constant &C); 291 void visitNamedMDNode(const NamedMDNode &NMD); 292 void visitMDNode(const MDNode &MD); 293 void visitMetadataAsValue(const MetadataAsValue &MD, Function *F); 294 void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F); 295 void visitComdat(const Comdat &C); 296 void visitModuleIdents(const Module &M); 297 void visitModuleFlags(const Module &M); 298 void visitModuleFlag(const MDNode *Op, 299 DenseMap<const MDString *, const MDNode *> &SeenIDs, 300 SmallVectorImpl<const MDNode *> &Requirements); 301 void visitFunction(const Function &F); 302 void visitBasicBlock(BasicBlock &BB); 303 void visitRangeMetadata(Instruction& I, MDNode* Range, Type* Ty); 304 305 template <class Ty> bool isValidMetadataArray(const MDTuple &N); 306 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N); 307 #include "llvm/IR/Metadata.def" 308 void visitMDScope(const MDScope &N); 309 void visitMDDerivedTypeBase(const MDDerivedTypeBase &N); 310 void visitMDVariable(const MDVariable &N); 311 void visitMDLexicalBlockBase(const MDLexicalBlockBase &N); 312 void visitMDTemplateParameter(const MDTemplateParameter &N); 313 314 void visitTemplateParams(const MDNode &N, const Metadata &RawParams); 315 316 /// \brief Check for a valid string-based type reference. 317 /// 318 /// Checks if \c MD is a string-based type reference. If it is, keeps track 319 /// of it (and its user, \c N) for error messages later. 320 bool isValidUUID(const MDNode &N, const Metadata *MD); 321 322 /// \brief Check for a valid type reference. 323 /// 324 /// Checks for subclasses of \a MDType, or \a isValidUUID(). 325 bool isTypeRef(const MDNode &N, const Metadata *MD); 326 327 /// \brief Check for a valid scope reference. 328 /// 329 /// Checks for subclasses of \a MDScope, or \a isValidUUID(). 330 bool isScopeRef(const MDNode &N, const Metadata *MD); 331 332 /// \brief Check for a valid debug info reference. 333 /// 334 /// Checks for subclasses of \a DebugNode, or \a isValidUUID(). 335 bool isDIRef(const MDNode &N, const Metadata *MD); 336 337 // InstVisitor overrides... 338 using InstVisitor<Verifier>::visit; 339 void visit(Instruction &I); 340 341 void visitTruncInst(TruncInst &I); 342 void visitZExtInst(ZExtInst &I); 343 void visitSExtInst(SExtInst &I); 344 void visitFPTruncInst(FPTruncInst &I); 345 void visitFPExtInst(FPExtInst &I); 346 void visitFPToUIInst(FPToUIInst &I); 347 void visitFPToSIInst(FPToSIInst &I); 348 void visitUIToFPInst(UIToFPInst &I); 349 void visitSIToFPInst(SIToFPInst &I); 350 void visitIntToPtrInst(IntToPtrInst &I); 351 void visitPtrToIntInst(PtrToIntInst &I); 352 void visitBitCastInst(BitCastInst &I); 353 void visitAddrSpaceCastInst(AddrSpaceCastInst &I); 354 void visitPHINode(PHINode &PN); 355 void visitBinaryOperator(BinaryOperator &B); 356 void visitICmpInst(ICmpInst &IC); 357 void visitFCmpInst(FCmpInst &FC); 358 void visitExtractElementInst(ExtractElementInst &EI); 359 void visitInsertElementInst(InsertElementInst &EI); 360 void visitShuffleVectorInst(ShuffleVectorInst &EI); 361 void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); } 362 void visitCallInst(CallInst &CI); 363 void visitInvokeInst(InvokeInst &II); 364 void visitGetElementPtrInst(GetElementPtrInst &GEP); 365 void visitLoadInst(LoadInst &LI); 366 void visitStoreInst(StoreInst &SI); 367 void verifyDominatesUse(Instruction &I, unsigned i); 368 void visitInstruction(Instruction &I); 369 void visitTerminatorInst(TerminatorInst &I); 370 void visitBranchInst(BranchInst &BI); 371 void visitReturnInst(ReturnInst &RI); 372 void visitSwitchInst(SwitchInst &SI); 373 void visitIndirectBrInst(IndirectBrInst &BI); 374 void visitSelectInst(SelectInst &SI); 375 void visitUserOp1(Instruction &I); 376 void visitUserOp2(Instruction &I) { visitUserOp1(I); } 377 void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI); 378 template <class DbgIntrinsicTy> 379 void visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII); 380 void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI); 381 void visitAtomicRMWInst(AtomicRMWInst &RMWI); 382 void visitFenceInst(FenceInst &FI); 383 void visitAllocaInst(AllocaInst &AI); 384 void visitExtractValueInst(ExtractValueInst &EVI); 385 void visitInsertValueInst(InsertValueInst &IVI); 386 void visitLandingPadInst(LandingPadInst &LPI); 387 388 void VerifyCallSite(CallSite CS); 389 void verifyMustTailCall(CallInst &CI); 390 bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT, 391 unsigned ArgNo, std::string &Suffix); 392 bool VerifyIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos, 393 SmallVectorImpl<Type *> &ArgTys); 394 bool VerifyIntrinsicIsVarArg(bool isVarArg, 395 ArrayRef<Intrinsic::IITDescriptor> &Infos); 396 bool VerifyAttributeCount(AttributeSet Attrs, unsigned Params); 397 void VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction, 398 const Value *V); 399 void VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 400 bool isReturnValue, const Value *V); 401 void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 402 const Value *V); 403 404 void VerifyConstantExprBitcastType(const ConstantExpr *CE); 405 void VerifyStatepoint(ImmutableCallSite CS); 406 void verifyFrameRecoverIndices(); 407 408 // Module-level debug info verification... 409 void verifyTypeRefs(); 410 template <class MapTy> 411 void verifyBitPieceExpression(const DbgInfoIntrinsic &I, 412 const MapTy &TypeRefs); 413 void visitUnresolvedTypeRef(const MDString *S, const MDNode *N); 414 }; 415 } // End anonymous namespace 416 417 // Assert - We know that cond should be true, if not print an error message. 418 #define Assert(C, ...) \ 419 do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (0) 420 421 void Verifier::visit(Instruction &I) { 422 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) 423 Assert(I.getOperand(i) != nullptr, "Operand is null", &I); 424 InstVisitor<Verifier>::visit(I); 425 } 426 427 428 void Verifier::visitGlobalValue(const GlobalValue &GV) { 429 Assert(!GV.isDeclaration() || GV.hasExternalLinkage() || 430 GV.hasExternalWeakLinkage(), 431 "Global is external, but doesn't have external or weak linkage!", &GV); 432 433 Assert(GV.getAlignment() <= Value::MaximumAlignment, 434 "huge alignment values are unsupported", &GV); 435 Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV), 436 "Only global variables can have appending linkage!", &GV); 437 438 if (GV.hasAppendingLinkage()) { 439 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV); 440 Assert(GVar && GVar->getType()->getElementType()->isArrayTy(), 441 "Only global arrays can have appending linkage!", GVar); 442 } 443 } 444 445 void Verifier::visitGlobalVariable(const GlobalVariable &GV) { 446 if (GV.hasInitializer()) { 447 Assert(GV.getInitializer()->getType() == GV.getType()->getElementType(), 448 "Global variable initializer type does not match global " 449 "variable type!", 450 &GV); 451 452 // If the global has common linkage, it must have a zero initializer and 453 // cannot be constant. 454 if (GV.hasCommonLinkage()) { 455 Assert(GV.getInitializer()->isNullValue(), 456 "'common' global must have a zero initializer!", &GV); 457 Assert(!GV.isConstant(), "'common' global may not be marked constant!", 458 &GV); 459 Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV); 460 } 461 } else { 462 Assert(GV.hasExternalLinkage() || GV.hasExternalWeakLinkage(), 463 "invalid linkage type for global declaration", &GV); 464 } 465 466 if (GV.hasName() && (GV.getName() == "llvm.global_ctors" || 467 GV.getName() == "llvm.global_dtors")) { 468 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(), 469 "invalid linkage for intrinsic global variable", &GV); 470 // Don't worry about emitting an error for it not being an array, 471 // visitGlobalValue will complain on appending non-array. 472 if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getType()->getElementType())) { 473 StructType *STy = dyn_cast<StructType>(ATy->getElementType()); 474 PointerType *FuncPtrTy = 475 FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo(); 476 // FIXME: Reject the 2-field form in LLVM 4.0. 477 Assert(STy && 478 (STy->getNumElements() == 2 || STy->getNumElements() == 3) && 479 STy->getTypeAtIndex(0u)->isIntegerTy(32) && 480 STy->getTypeAtIndex(1) == FuncPtrTy, 481 "wrong type for intrinsic global variable", &GV); 482 if (STy->getNumElements() == 3) { 483 Type *ETy = STy->getTypeAtIndex(2); 484 Assert(ETy->isPointerTy() && 485 cast<PointerType>(ETy)->getElementType()->isIntegerTy(8), 486 "wrong type for intrinsic global variable", &GV); 487 } 488 } 489 } 490 491 if (GV.hasName() && (GV.getName() == "llvm.used" || 492 GV.getName() == "llvm.compiler.used")) { 493 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(), 494 "invalid linkage for intrinsic global variable", &GV); 495 Type *GVType = GV.getType()->getElementType(); 496 if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) { 497 PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType()); 498 Assert(PTy, "wrong type for intrinsic global variable", &GV); 499 if (GV.hasInitializer()) { 500 const Constant *Init = GV.getInitializer(); 501 const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init); 502 Assert(InitArray, "wrong initalizer for intrinsic global variable", 503 Init); 504 for (unsigned i = 0, e = InitArray->getNumOperands(); i != e; ++i) { 505 Value *V = Init->getOperand(i)->stripPointerCastsNoFollowAliases(); 506 Assert(isa<GlobalVariable>(V) || isa<Function>(V) || 507 isa<GlobalAlias>(V), 508 "invalid llvm.used member", V); 509 Assert(V->hasName(), "members of llvm.used must be named", V); 510 } 511 } 512 } 513 } 514 515 Assert(!GV.hasDLLImportStorageClass() || 516 (GV.isDeclaration() && GV.hasExternalLinkage()) || 517 GV.hasAvailableExternallyLinkage(), 518 "Global is marked as dllimport, but not external", &GV); 519 520 if (!GV.hasInitializer()) { 521 visitGlobalValue(GV); 522 return; 523 } 524 525 // Walk any aggregate initializers looking for bitcasts between address spaces 526 SmallPtrSet<const Value *, 4> Visited; 527 SmallVector<const Value *, 4> WorkStack; 528 WorkStack.push_back(cast<Value>(GV.getInitializer())); 529 530 while (!WorkStack.empty()) { 531 const Value *V = WorkStack.pop_back_val(); 532 if (!Visited.insert(V).second) 533 continue; 534 535 if (const User *U = dyn_cast<User>(V)) { 536 WorkStack.append(U->op_begin(), U->op_end()); 537 } 538 539 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 540 VerifyConstantExprBitcastType(CE); 541 if (Broken) 542 return; 543 } 544 } 545 546 visitGlobalValue(GV); 547 } 548 549 void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) { 550 SmallPtrSet<const GlobalAlias*, 4> Visited; 551 Visited.insert(&GA); 552 visitAliaseeSubExpr(Visited, GA, C); 553 } 554 555 void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited, 556 const GlobalAlias &GA, const Constant &C) { 557 if (const auto *GV = dyn_cast<GlobalValue>(&C)) { 558 Assert(!GV->isDeclaration(), "Alias must point to a definition", &GA); 559 560 if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) { 561 Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA); 562 563 Assert(!GA2->mayBeOverridden(), "Alias cannot point to a weak alias", 564 &GA); 565 } else { 566 // Only continue verifying subexpressions of GlobalAliases. 567 // Do not recurse into global initializers. 568 return; 569 } 570 } 571 572 if (const auto *CE = dyn_cast<ConstantExpr>(&C)) 573 VerifyConstantExprBitcastType(CE); 574 575 for (const Use &U : C.operands()) { 576 Value *V = &*U; 577 if (const auto *GA2 = dyn_cast<GlobalAlias>(V)) 578 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee()); 579 else if (const auto *C2 = dyn_cast<Constant>(V)) 580 visitAliaseeSubExpr(Visited, GA, *C2); 581 } 582 } 583 584 void Verifier::visitGlobalAlias(const GlobalAlias &GA) { 585 Assert(!GA.getName().empty(), "Alias name cannot be empty!", &GA); 586 Assert(GlobalAlias::isValidLinkage(GA.getLinkage()), 587 "Alias should have private, internal, linkonce, weak, linkonce_odr, " 588 "weak_odr, or external linkage!", 589 &GA); 590 const Constant *Aliasee = GA.getAliasee(); 591 Assert(Aliasee, "Aliasee cannot be NULL!", &GA); 592 Assert(GA.getType() == Aliasee->getType(), 593 "Alias and aliasee types should match!", &GA); 594 595 Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee), 596 "Aliasee should be either GlobalValue or ConstantExpr", &GA); 597 598 visitAliaseeSubExpr(GA, *Aliasee); 599 600 visitGlobalValue(GA); 601 } 602 603 void Verifier::visitNamedMDNode(const NamedMDNode &NMD) { 604 for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) { 605 MDNode *MD = NMD.getOperand(i); 606 607 if (NMD.getName() == "llvm.dbg.cu") { 608 Assert(MD && isa<MDCompileUnit>(MD), "invalid compile unit", &NMD, MD); 609 } 610 611 if (!MD) 612 continue; 613 614 visitMDNode(*MD); 615 } 616 } 617 618 void Verifier::visitMDNode(const MDNode &MD) { 619 // Only visit each node once. Metadata can be mutually recursive, so this 620 // avoids infinite recursion here, as well as being an optimization. 621 if (!MDNodes.insert(&MD).second) 622 return; 623 624 switch (MD.getMetadataID()) { 625 default: 626 llvm_unreachable("Invalid MDNode subclass"); 627 case Metadata::MDTupleKind: 628 break; 629 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \ 630 case Metadata::CLASS##Kind: \ 631 visit##CLASS(cast<CLASS>(MD)); \ 632 break; 633 #include "llvm/IR/Metadata.def" 634 } 635 636 for (unsigned i = 0, e = MD.getNumOperands(); i != e; ++i) { 637 Metadata *Op = MD.getOperand(i); 638 if (!Op) 639 continue; 640 Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!", 641 &MD, Op); 642 if (auto *N = dyn_cast<MDNode>(Op)) { 643 visitMDNode(*N); 644 continue; 645 } 646 if (auto *V = dyn_cast<ValueAsMetadata>(Op)) { 647 visitValueAsMetadata(*V, nullptr); 648 continue; 649 } 650 } 651 652 // Check these last, so we diagnose problems in operands first. 653 Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD); 654 Assert(MD.isResolved(), "All nodes should be resolved!", &MD); 655 } 656 657 void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) { 658 Assert(MD.getValue(), "Expected valid value", &MD); 659 Assert(!MD.getValue()->getType()->isMetadataTy(), 660 "Unexpected metadata round-trip through values", &MD, MD.getValue()); 661 662 auto *L = dyn_cast<LocalAsMetadata>(&MD); 663 if (!L) 664 return; 665 666 Assert(F, "function-local metadata used outside a function", L); 667 668 // If this was an instruction, bb, or argument, verify that it is in the 669 // function that we expect. 670 Function *ActualF = nullptr; 671 if (Instruction *I = dyn_cast<Instruction>(L->getValue())) { 672 Assert(I->getParent(), "function-local metadata not in basic block", L, I); 673 ActualF = I->getParent()->getParent(); 674 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue())) 675 ActualF = BB->getParent(); 676 else if (Argument *A = dyn_cast<Argument>(L->getValue())) 677 ActualF = A->getParent(); 678 assert(ActualF && "Unimplemented function local metadata case!"); 679 680 Assert(ActualF == F, "function-local metadata used in wrong function", L); 681 } 682 683 void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) { 684 Metadata *MD = MDV.getMetadata(); 685 if (auto *N = dyn_cast<MDNode>(MD)) { 686 visitMDNode(*N); 687 return; 688 } 689 690 // Only visit each node once. Metadata can be mutually recursive, so this 691 // avoids infinite recursion here, as well as being an optimization. 692 if (!MDNodes.insert(MD).second) 693 return; 694 695 if (auto *V = dyn_cast<ValueAsMetadata>(MD)) 696 visitValueAsMetadata(*V, F); 697 } 698 699 bool Verifier::isValidUUID(const MDNode &N, const Metadata *MD) { 700 auto *S = dyn_cast<MDString>(MD); 701 if (!S) 702 return false; 703 if (S->getString().empty()) 704 return false; 705 706 // Keep track of names of types referenced via UUID so we can check that they 707 // actually exist. 708 UnresolvedTypeRefs.insert(std::make_pair(S, &N)); 709 return true; 710 } 711 712 /// \brief Check if a value can be a reference to a type. 713 bool Verifier::isTypeRef(const MDNode &N, const Metadata *MD) { 714 return !MD || isValidUUID(N, MD) || isa<MDType>(MD); 715 } 716 717 /// \brief Check if a value can be a ScopeRef. 718 bool Verifier::isScopeRef(const MDNode &N, const Metadata *MD) { 719 return !MD || isValidUUID(N, MD) || isa<MDScope>(MD); 720 } 721 722 /// \brief Check if a value can be a debug info ref. 723 bool Verifier::isDIRef(const MDNode &N, const Metadata *MD) { 724 return !MD || isValidUUID(N, MD) || isa<DebugNode>(MD); 725 } 726 727 template <class Ty> 728 bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull) { 729 for (Metadata *MD : N.operands()) { 730 if (MD) { 731 if (!isa<Ty>(MD)) 732 return false; 733 } else { 734 if (!AllowNull) 735 return false; 736 } 737 } 738 return true; 739 } 740 741 template <class Ty> 742 bool isValidMetadataArray(const MDTuple &N) { 743 return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ false); 744 } 745 746 template <class Ty> 747 bool isValidMetadataNullArray(const MDTuple &N) { 748 return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ true); 749 } 750 751 void Verifier::visitMDLocation(const MDLocation &N) { 752 Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), 753 "location requires a valid scope", &N, N.getRawScope()); 754 if (auto *IA = N.getRawInlinedAt()) 755 Assert(isa<MDLocation>(IA), "inlined-at should be a location", &N, IA); 756 } 757 758 void Verifier::visitGenericDebugNode(const GenericDebugNode &N) { 759 Assert(N.getTag(), "invalid tag", &N); 760 } 761 762 void Verifier::visitMDScope(const MDScope &N) { 763 if (auto *F = N.getRawFile()) 764 Assert(isa<MDFile>(F), "invalid file", &N, F); 765 } 766 767 void Verifier::visitMDSubrange(const MDSubrange &N) { 768 Assert(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N); 769 Assert(N.getCount() >= -1, "invalid subrange count", &N); 770 } 771 772 void Verifier::visitMDEnumerator(const MDEnumerator &N) { 773 Assert(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N); 774 } 775 776 void Verifier::visitMDBasicType(const MDBasicType &N) { 777 Assert(N.getTag() == dwarf::DW_TAG_base_type || 778 N.getTag() == dwarf::DW_TAG_unspecified_type, 779 "invalid tag", &N); 780 } 781 782 void Verifier::visitMDDerivedTypeBase(const MDDerivedTypeBase &N) { 783 // Common scope checks. 784 visitMDScope(N); 785 786 Assert(isScopeRef(N, N.getScope()), "invalid scope", &N, N.getScope()); 787 Assert(isTypeRef(N, N.getBaseType()), "invalid base type", &N, 788 N.getBaseType()); 789 790 // FIXME: Sink this into the subclass verifies. 791 if (!N.getFile() || N.getFile()->getFilename().empty()) { 792 // Check whether the filename is allowed to be empty. 793 uint16_t Tag = N.getTag(); 794 Assert( 795 Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type || 796 Tag == dwarf::DW_TAG_pointer_type || 797 Tag == dwarf::DW_TAG_ptr_to_member_type || 798 Tag == dwarf::DW_TAG_reference_type || 799 Tag == dwarf::DW_TAG_rvalue_reference_type || 800 Tag == dwarf::DW_TAG_restrict_type || 801 Tag == dwarf::DW_TAG_array_type || 802 Tag == dwarf::DW_TAG_enumeration_type || 803 Tag == dwarf::DW_TAG_subroutine_type || 804 Tag == dwarf::DW_TAG_inheritance || Tag == dwarf::DW_TAG_friend || 805 Tag == dwarf::DW_TAG_structure_type || 806 Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef, 807 "derived/composite type requires a filename", &N, N.getFile()); 808 } 809 } 810 811 void Verifier::visitMDDerivedType(const MDDerivedType &N) { 812 // Common derived type checks. 813 visitMDDerivedTypeBase(N); 814 815 Assert(N.getTag() == dwarf::DW_TAG_typedef || 816 N.getTag() == dwarf::DW_TAG_pointer_type || 817 N.getTag() == dwarf::DW_TAG_ptr_to_member_type || 818 N.getTag() == dwarf::DW_TAG_reference_type || 819 N.getTag() == dwarf::DW_TAG_rvalue_reference_type || 820 N.getTag() == dwarf::DW_TAG_const_type || 821 N.getTag() == dwarf::DW_TAG_volatile_type || 822 N.getTag() == dwarf::DW_TAG_restrict_type || 823 N.getTag() == dwarf::DW_TAG_member || 824 N.getTag() == dwarf::DW_TAG_inheritance || 825 N.getTag() == dwarf::DW_TAG_friend, 826 "invalid tag", &N); 827 if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) { 828 Assert(isTypeRef(N, N.getExtraData()), "invalid pointer to member type", &N, 829 N.getExtraData()); 830 } 831 } 832 833 static bool hasConflictingReferenceFlags(unsigned Flags) { 834 return (Flags & DebugNode::FlagLValueReference) && 835 (Flags & DebugNode::FlagRValueReference); 836 } 837 838 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) { 839 auto *Params = dyn_cast<MDTuple>(&RawParams); 840 Assert(Params, "invalid template params", &N, &RawParams); 841 for (Metadata *Op : Params->operands()) { 842 Assert(Op && isa<MDTemplateParameter>(Op), "invalid template parameter", &N, 843 Params, Op); 844 } 845 } 846 847 void Verifier::visitMDCompositeType(const MDCompositeType &N) { 848 // Common derived type checks. 849 visitMDDerivedTypeBase(N); 850 851 Assert(N.getTag() == dwarf::DW_TAG_array_type || 852 N.getTag() == dwarf::DW_TAG_structure_type || 853 N.getTag() == dwarf::DW_TAG_union_type || 854 N.getTag() == dwarf::DW_TAG_enumeration_type || 855 N.getTag() == dwarf::DW_TAG_subroutine_type || 856 N.getTag() == dwarf::DW_TAG_class_type, 857 "invalid tag", &N); 858 859 Assert(!N.getRawElements() || isa<MDTuple>(N.getRawElements()), 860 "invalid composite elements", &N, N.getRawElements()); 861 Assert(isTypeRef(N, N.getRawVTableHolder()), "invalid vtable holder", &N, 862 N.getRawVTableHolder()); 863 Assert(!N.getRawElements() || isa<MDTuple>(N.getRawElements()), 864 "invalid composite elements", &N, N.getRawElements()); 865 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 866 &N); 867 if (auto *Params = N.getRawTemplateParams()) 868 visitTemplateParams(N, *Params); 869 } 870 871 void Verifier::visitMDSubroutineType(const MDSubroutineType &N) { 872 Assert(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N); 873 if (auto *Types = N.getRawTypeArray()) { 874 Assert(isa<MDTuple>(Types), "invalid composite elements", &N, Types); 875 for (Metadata *Ty : N.getTypeArray()->operands()) { 876 Assert(isTypeRef(N, Ty), "invalid subroutine type ref", &N, Types, Ty); 877 } 878 } 879 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 880 &N); 881 } 882 883 void Verifier::visitMDFile(const MDFile &N) { 884 Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N); 885 } 886 887 void Verifier::visitMDCompileUnit(const MDCompileUnit &N) { 888 Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N); 889 890 // Don't bother verifying the compilation directory or producer string 891 // as those could be empty. 892 Assert(N.getRawFile() && isa<MDFile>(N.getRawFile()), 893 "invalid file", &N, N.getRawFile()); 894 Assert(!N.getFile()->getFilename().empty(), "invalid filename", &N, 895 N.getFile()); 896 897 if (auto *Array = N.getRawEnumTypes()) { 898 Assert(isa<MDTuple>(Array), "invalid enum list", &N, Array); 899 for (Metadata *Op : N.getEnumTypes()->operands()) { 900 auto *Enum = dyn_cast_or_null<MDCompositeType>(Op); 901 Assert(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type, 902 "invalid enum type", &N, N.getEnumTypes(), Op); 903 } 904 } 905 if (auto *Array = N.getRawRetainedTypes()) { 906 Assert(isa<MDTuple>(Array), "invalid retained type list", &N, Array); 907 for (Metadata *Op : N.getRetainedTypes()->operands()) { 908 Assert(Op && isa<MDType>(Op), "invalid retained type", &N, Op); 909 } 910 } 911 if (auto *Array = N.getRawSubprograms()) { 912 Assert(isa<MDTuple>(Array), "invalid subprogram list", &N, Array); 913 for (Metadata *Op : N.getSubprograms()->operands()) { 914 Assert(Op && isa<MDSubprogram>(Op), "invalid subprogram ref", &N, Op); 915 } 916 } 917 if (auto *Array = N.getRawGlobalVariables()) { 918 Assert(isa<MDTuple>(Array), "invalid global variable list", &N, Array); 919 for (Metadata *Op : N.getGlobalVariables()->operands()) { 920 Assert(Op && isa<MDGlobalVariable>(Op), "invalid global variable ref", &N, 921 Op); 922 } 923 } 924 if (auto *Array = N.getRawImportedEntities()) { 925 Assert(isa<MDTuple>(Array), "invalid imported entity list", &N, Array); 926 for (Metadata *Op : N.getImportedEntities()->operands()) { 927 Assert(Op && isa<MDImportedEntity>(Op), "invalid imported entity ref", &N, 928 Op); 929 } 930 } 931 } 932 933 void Verifier::visitMDSubprogram(const MDSubprogram &N) { 934 Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N); 935 Assert(isScopeRef(N, N.getRawScope()), "invalid scope", &N, N.getRawScope()); 936 if (auto *T = N.getRawType()) 937 Assert(isa<MDSubroutineType>(T), "invalid subroutine type", &N, T); 938 Assert(isTypeRef(N, N.getRawContainingType()), "invalid containing type", &N, 939 N.getRawContainingType()); 940 if (auto *RawF = N.getRawFunction()) { 941 auto *FMD = dyn_cast<ConstantAsMetadata>(RawF); 942 auto *F = FMD ? FMD->getValue() : nullptr; 943 auto *FT = F ? dyn_cast<PointerType>(F->getType()) : nullptr; 944 Assert(F && FT && isa<FunctionType>(FT->getElementType()), 945 "invalid function", &N, F, FT); 946 } 947 if (auto *Params = N.getRawTemplateParams()) 948 visitTemplateParams(N, *Params); 949 if (auto *S = N.getRawDeclaration()) { 950 Assert(isa<MDSubprogram>(S) && !cast<MDSubprogram>(S)->isDefinition(), 951 "invalid subprogram declaration", &N, S); 952 } 953 if (auto *RawVars = N.getRawVariables()) { 954 auto *Vars = dyn_cast<MDTuple>(RawVars); 955 Assert(Vars, "invalid variable list", &N, RawVars); 956 for (Metadata *Op : Vars->operands()) { 957 Assert(Op && isa<MDLocalVariable>(Op), "invalid local variable", &N, Vars, 958 Op); 959 } 960 } 961 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 962 &N); 963 964 auto *F = N.getFunction(); 965 if (!F) 966 return; 967 968 // Check that all !dbg attachments lead to back to N (or, at least, another 969 // subprogram that describes the same function). 970 // 971 // FIXME: Check this incrementally while visiting !dbg attachments. 972 // FIXME: Only check when N is the canonical subprogram for F. 973 SmallPtrSet<const MDNode *, 32> Seen; 974 for (auto &BB : *F) 975 for (auto &I : BB) { 976 // Be careful about using MDLocation here since we might be dealing with 977 // broken code (this is the Verifier after all). 978 MDLocation *DL = 979 dyn_cast_or_null<MDLocation>(I.getDebugLoc().getAsMDNode()); 980 if (!DL) 981 continue; 982 if (!Seen.insert(DL).second) 983 continue; 984 985 MDLocalScope *Scope = DL->getInlinedAtScope(); 986 if (Scope && !Seen.insert(Scope).second) 987 continue; 988 989 MDSubprogram *SP = Scope ? Scope->getSubprogram() : nullptr; 990 if (SP && !Seen.insert(SP).second) 991 continue; 992 993 // FIXME: Once N is canonical, check "SP == &N". 994 Assert(SP->describes(F), 995 "!dbg attachment points at wrong subprogram for function", &N, F, 996 &I, DL, Scope, SP); 997 } 998 } 999 1000 void Verifier::visitMDLexicalBlockBase(const MDLexicalBlockBase &N) { 1001 Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N); 1002 Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), 1003 "invalid local scope", &N, N.getRawScope()); 1004 } 1005 1006 void Verifier::visitMDLexicalBlock(const MDLexicalBlock &N) { 1007 visitMDLexicalBlockBase(N); 1008 1009 Assert(N.getLine() || !N.getColumn(), 1010 "cannot have column info without line info", &N); 1011 } 1012 1013 void Verifier::visitMDLexicalBlockFile(const MDLexicalBlockFile &N) { 1014 visitMDLexicalBlockBase(N); 1015 } 1016 1017 void Verifier::visitMDNamespace(const MDNamespace &N) { 1018 Assert(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N); 1019 if (auto *S = N.getRawScope()) 1020 Assert(isa<MDScope>(S), "invalid scope ref", &N, S); 1021 } 1022 1023 void Verifier::visitMDTemplateParameter(const MDTemplateParameter &N) { 1024 Assert(isTypeRef(N, N.getType()), "invalid type ref", &N, N.getType()); 1025 } 1026 1027 void Verifier::visitMDTemplateTypeParameter(const MDTemplateTypeParameter &N) { 1028 visitMDTemplateParameter(N); 1029 1030 Assert(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag", 1031 &N); 1032 } 1033 1034 void Verifier::visitMDTemplateValueParameter( 1035 const MDTemplateValueParameter &N) { 1036 visitMDTemplateParameter(N); 1037 1038 Assert(N.getTag() == dwarf::DW_TAG_template_value_parameter || 1039 N.getTag() == dwarf::DW_TAG_GNU_template_template_param || 1040 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack, 1041 "invalid tag", &N); 1042 } 1043 1044 void Verifier::visitMDVariable(const MDVariable &N) { 1045 if (auto *S = N.getRawScope()) 1046 Assert(isa<MDScope>(S), "invalid scope", &N, S); 1047 Assert(isTypeRef(N, N.getRawType()), "invalid type ref", &N, N.getRawType()); 1048 if (auto *F = N.getRawFile()) 1049 Assert(isa<MDFile>(F), "invalid file", &N, F); 1050 } 1051 1052 void Verifier::visitMDGlobalVariable(const MDGlobalVariable &N) { 1053 // Checks common to all variables. 1054 visitMDVariable(N); 1055 1056 Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N); 1057 Assert(!N.getName().empty(), "missing global variable name", &N); 1058 if (auto *V = N.getRawVariable()) { 1059 Assert(isa<ConstantAsMetadata>(V) && 1060 !isa<Function>(cast<ConstantAsMetadata>(V)->getValue()), 1061 "invalid global varaible ref", &N, V); 1062 } 1063 if (auto *Member = N.getRawStaticDataMemberDeclaration()) { 1064 Assert(isa<MDDerivedType>(Member), "invalid static data member declaration", 1065 &N, Member); 1066 } 1067 } 1068 1069 void Verifier::visitMDLocalVariable(const MDLocalVariable &N) { 1070 // Checks common to all variables. 1071 visitMDVariable(N); 1072 1073 Assert(N.getTag() == dwarf::DW_TAG_auto_variable || 1074 N.getTag() == dwarf::DW_TAG_arg_variable, 1075 "invalid tag", &N); 1076 Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), 1077 "local variable requires a valid scope", &N, N.getRawScope()); 1078 } 1079 1080 void Verifier::visitMDExpression(const MDExpression &N) { 1081 Assert(N.isValid(), "invalid expression", &N); 1082 } 1083 1084 void Verifier::visitMDObjCProperty(const MDObjCProperty &N) { 1085 Assert(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N); 1086 if (auto *T = N.getRawType()) 1087 Assert(isa<MDType>(T), "invalid type ref", &N, T); 1088 if (auto *F = N.getRawFile()) 1089 Assert(isa<MDFile>(F), "invalid file", &N, F); 1090 } 1091 1092 void Verifier::visitMDImportedEntity(const MDImportedEntity &N) { 1093 Assert(N.getTag() == dwarf::DW_TAG_imported_module || 1094 N.getTag() == dwarf::DW_TAG_imported_declaration, 1095 "invalid tag", &N); 1096 if (auto *S = N.getRawScope()) 1097 Assert(isa<MDScope>(S), "invalid scope for imported entity", &N, S); 1098 Assert(isDIRef(N, N.getEntity()), "invalid imported entity", &N, 1099 N.getEntity()); 1100 } 1101 1102 void Verifier::visitComdat(const Comdat &C) { 1103 // The Module is invalid if the GlobalValue has private linkage. Entities 1104 // with private linkage don't have entries in the symbol table. 1105 if (const GlobalValue *GV = M->getNamedValue(C.getName())) 1106 Assert(!GV->hasPrivateLinkage(), "comdat global value has private linkage", 1107 GV); 1108 } 1109 1110 void Verifier::visitModuleIdents(const Module &M) { 1111 const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident"); 1112 if (!Idents) 1113 return; 1114 1115 // llvm.ident takes a list of metadata entry. Each entry has only one string. 1116 // Scan each llvm.ident entry and make sure that this requirement is met. 1117 for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) { 1118 const MDNode *N = Idents->getOperand(i); 1119 Assert(N->getNumOperands() == 1, 1120 "incorrect number of operands in llvm.ident metadata", N); 1121 Assert(dyn_cast_or_null<MDString>(N->getOperand(0)), 1122 ("invalid value for llvm.ident metadata entry operand" 1123 "(the operand should be a string)"), 1124 N->getOperand(0)); 1125 } 1126 } 1127 1128 void Verifier::visitModuleFlags(const Module &M) { 1129 const NamedMDNode *Flags = M.getModuleFlagsMetadata(); 1130 if (!Flags) return; 1131 1132 // Scan each flag, and track the flags and requirements. 1133 DenseMap<const MDString*, const MDNode*> SeenIDs; 1134 SmallVector<const MDNode*, 16> Requirements; 1135 for (unsigned I = 0, E = Flags->getNumOperands(); I != E; ++I) { 1136 visitModuleFlag(Flags->getOperand(I), SeenIDs, Requirements); 1137 } 1138 1139 // Validate that the requirements in the module are valid. 1140 for (unsigned I = 0, E = Requirements.size(); I != E; ++I) { 1141 const MDNode *Requirement = Requirements[I]; 1142 const MDString *Flag = cast<MDString>(Requirement->getOperand(0)); 1143 const Metadata *ReqValue = Requirement->getOperand(1); 1144 1145 const MDNode *Op = SeenIDs.lookup(Flag); 1146 if (!Op) { 1147 CheckFailed("invalid requirement on flag, flag is not present in module", 1148 Flag); 1149 continue; 1150 } 1151 1152 if (Op->getOperand(2) != ReqValue) { 1153 CheckFailed(("invalid requirement on flag, " 1154 "flag does not have the required value"), 1155 Flag); 1156 continue; 1157 } 1158 } 1159 } 1160 1161 void 1162 Verifier::visitModuleFlag(const MDNode *Op, 1163 DenseMap<const MDString *, const MDNode *> &SeenIDs, 1164 SmallVectorImpl<const MDNode *> &Requirements) { 1165 // Each module flag should have three arguments, the merge behavior (a 1166 // constant int), the flag ID (an MDString), and the value. 1167 Assert(Op->getNumOperands() == 3, 1168 "incorrect number of operands in module flag", Op); 1169 Module::ModFlagBehavior MFB; 1170 if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) { 1171 Assert( 1172 mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)), 1173 "invalid behavior operand in module flag (expected constant integer)", 1174 Op->getOperand(0)); 1175 Assert(false, 1176 "invalid behavior operand in module flag (unexpected constant)", 1177 Op->getOperand(0)); 1178 } 1179 MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1)); 1180 Assert(ID, "invalid ID operand in module flag (expected metadata string)", 1181 Op->getOperand(1)); 1182 1183 // Sanity check the values for behaviors with additional requirements. 1184 switch (MFB) { 1185 case Module::Error: 1186 case Module::Warning: 1187 case Module::Override: 1188 // These behavior types accept any value. 1189 break; 1190 1191 case Module::Require: { 1192 // The value should itself be an MDNode with two operands, a flag ID (an 1193 // MDString), and a value. 1194 MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2)); 1195 Assert(Value && Value->getNumOperands() == 2, 1196 "invalid value for 'require' module flag (expected metadata pair)", 1197 Op->getOperand(2)); 1198 Assert(isa<MDString>(Value->getOperand(0)), 1199 ("invalid value for 'require' module flag " 1200 "(first value operand should be a string)"), 1201 Value->getOperand(0)); 1202 1203 // Append it to the list of requirements, to check once all module flags are 1204 // scanned. 1205 Requirements.push_back(Value); 1206 break; 1207 } 1208 1209 case Module::Append: 1210 case Module::AppendUnique: { 1211 // These behavior types require the operand be an MDNode. 1212 Assert(isa<MDNode>(Op->getOperand(2)), 1213 "invalid value for 'append'-type module flag " 1214 "(expected a metadata node)", 1215 Op->getOperand(2)); 1216 break; 1217 } 1218 } 1219 1220 // Unless this is a "requires" flag, check the ID is unique. 1221 if (MFB != Module::Require) { 1222 bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second; 1223 Assert(Inserted, 1224 "module flag identifiers must be unique (or of 'require' type)", ID); 1225 } 1226 } 1227 1228 void Verifier::VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, 1229 bool isFunction, const Value *V) { 1230 unsigned Slot = ~0U; 1231 for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I) 1232 if (Attrs.getSlotIndex(I) == Idx) { 1233 Slot = I; 1234 break; 1235 } 1236 1237 assert(Slot != ~0U && "Attribute set inconsistency!"); 1238 1239 for (AttributeSet::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot); 1240 I != E; ++I) { 1241 if (I->isStringAttribute()) 1242 continue; 1243 1244 if (I->getKindAsEnum() == Attribute::NoReturn || 1245 I->getKindAsEnum() == Attribute::NoUnwind || 1246 I->getKindAsEnum() == Attribute::NoInline || 1247 I->getKindAsEnum() == Attribute::AlwaysInline || 1248 I->getKindAsEnum() == Attribute::OptimizeForSize || 1249 I->getKindAsEnum() == Attribute::StackProtect || 1250 I->getKindAsEnum() == Attribute::StackProtectReq || 1251 I->getKindAsEnum() == Attribute::StackProtectStrong || 1252 I->getKindAsEnum() == Attribute::NoRedZone || 1253 I->getKindAsEnum() == Attribute::NoImplicitFloat || 1254 I->getKindAsEnum() == Attribute::Naked || 1255 I->getKindAsEnum() == Attribute::InlineHint || 1256 I->getKindAsEnum() == Attribute::StackAlignment || 1257 I->getKindAsEnum() == Attribute::UWTable || 1258 I->getKindAsEnum() == Attribute::NonLazyBind || 1259 I->getKindAsEnum() == Attribute::ReturnsTwice || 1260 I->getKindAsEnum() == Attribute::SanitizeAddress || 1261 I->getKindAsEnum() == Attribute::SanitizeThread || 1262 I->getKindAsEnum() == Attribute::SanitizeMemory || 1263 I->getKindAsEnum() == Attribute::MinSize || 1264 I->getKindAsEnum() == Attribute::NoDuplicate || 1265 I->getKindAsEnum() == Attribute::Builtin || 1266 I->getKindAsEnum() == Attribute::NoBuiltin || 1267 I->getKindAsEnum() == Attribute::Cold || 1268 I->getKindAsEnum() == Attribute::OptimizeNone || 1269 I->getKindAsEnum() == Attribute::JumpTable) { 1270 if (!isFunction) { 1271 CheckFailed("Attribute '" + I->getAsString() + 1272 "' only applies to functions!", V); 1273 return; 1274 } 1275 } else if (I->getKindAsEnum() == Attribute::ReadOnly || 1276 I->getKindAsEnum() == Attribute::ReadNone) { 1277 if (Idx == 0) { 1278 CheckFailed("Attribute '" + I->getAsString() + 1279 "' does not apply to function returns"); 1280 return; 1281 } 1282 } else if (isFunction) { 1283 CheckFailed("Attribute '" + I->getAsString() + 1284 "' does not apply to functions!", V); 1285 return; 1286 } 1287 } 1288 } 1289 1290 // VerifyParameterAttrs - Check the given attributes for an argument or return 1291 // value of the specified type. The value V is printed in error messages. 1292 void Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 1293 bool isReturnValue, const Value *V) { 1294 if (!Attrs.hasAttributes(Idx)) 1295 return; 1296 1297 VerifyAttributeTypes(Attrs, Idx, false, V); 1298 1299 if (isReturnValue) 1300 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && 1301 !Attrs.hasAttribute(Idx, Attribute::Nest) && 1302 !Attrs.hasAttribute(Idx, Attribute::StructRet) && 1303 !Attrs.hasAttribute(Idx, Attribute::NoCapture) && 1304 !Attrs.hasAttribute(Idx, Attribute::Returned) && 1305 !Attrs.hasAttribute(Idx, Attribute::InAlloca), 1306 "Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', and " 1307 "'returned' do not apply to return values!", 1308 V); 1309 1310 // Check for mutually incompatible attributes. Only inreg is compatible with 1311 // sret. 1312 unsigned AttrCount = 0; 1313 AttrCount += Attrs.hasAttribute(Idx, Attribute::ByVal); 1314 AttrCount += Attrs.hasAttribute(Idx, Attribute::InAlloca); 1315 AttrCount += Attrs.hasAttribute(Idx, Attribute::StructRet) || 1316 Attrs.hasAttribute(Idx, Attribute::InReg); 1317 AttrCount += Attrs.hasAttribute(Idx, Attribute::Nest); 1318 Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', " 1319 "and 'sret' are incompatible!", 1320 V); 1321 1322 Assert(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) && 1323 Attrs.hasAttribute(Idx, Attribute::ReadOnly)), 1324 "Attributes " 1325 "'inalloca and readonly' are incompatible!", 1326 V); 1327 1328 Assert(!(Attrs.hasAttribute(Idx, Attribute::StructRet) && 1329 Attrs.hasAttribute(Idx, Attribute::Returned)), 1330 "Attributes " 1331 "'sret and returned' are incompatible!", 1332 V); 1333 1334 Assert(!(Attrs.hasAttribute(Idx, Attribute::ZExt) && 1335 Attrs.hasAttribute(Idx, Attribute::SExt)), 1336 "Attributes " 1337 "'zeroext and signext' are incompatible!", 1338 V); 1339 1340 Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) && 1341 Attrs.hasAttribute(Idx, Attribute::ReadOnly)), 1342 "Attributes " 1343 "'readnone and readonly' are incompatible!", 1344 V); 1345 1346 Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) && 1347 Attrs.hasAttribute(Idx, Attribute::AlwaysInline)), 1348 "Attributes " 1349 "'noinline and alwaysinline' are incompatible!", 1350 V); 1351 1352 Assert(!AttrBuilder(Attrs, Idx) 1353 .hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx), 1354 "Wrong types for attribute: " + 1355 AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx), 1356 V); 1357 1358 if (PointerType *PTy = dyn_cast<PointerType>(Ty)) { 1359 SmallPtrSet<const Type*, 4> Visited; 1360 if (!PTy->getElementType()->isSized(&Visited)) { 1361 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && 1362 !Attrs.hasAttribute(Idx, Attribute::InAlloca), 1363 "Attributes 'byval' and 'inalloca' do not support unsized types!", 1364 V); 1365 } 1366 } else { 1367 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal), 1368 "Attribute 'byval' only applies to parameters with pointer type!", 1369 V); 1370 } 1371 } 1372 1373 // VerifyFunctionAttrs - Check parameter attributes against a function type. 1374 // The value V is printed in error messages. 1375 void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 1376 const Value *V) { 1377 if (Attrs.isEmpty()) 1378 return; 1379 1380 bool SawNest = false; 1381 bool SawReturned = false; 1382 bool SawSRet = false; 1383 1384 for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { 1385 unsigned Idx = Attrs.getSlotIndex(i); 1386 1387 Type *Ty; 1388 if (Idx == 0) 1389 Ty = FT->getReturnType(); 1390 else if (Idx-1 < FT->getNumParams()) 1391 Ty = FT->getParamType(Idx-1); 1392 else 1393 break; // VarArgs attributes, verified elsewhere. 1394 1395 VerifyParameterAttrs(Attrs, Idx, Ty, Idx == 0, V); 1396 1397 if (Idx == 0) 1398 continue; 1399 1400 if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 1401 Assert(!SawNest, "More than one parameter has attribute nest!", V); 1402 SawNest = true; 1403 } 1404 1405 if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 1406 Assert(!SawReturned, "More than one parameter has attribute returned!", 1407 V); 1408 Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()), 1409 "Incompatible " 1410 "argument and return types for 'returned' attribute", 1411 V); 1412 SawReturned = true; 1413 } 1414 1415 if (Attrs.hasAttribute(Idx, Attribute::StructRet)) { 1416 Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V); 1417 Assert(Idx == 1 || Idx == 2, 1418 "Attribute 'sret' is not on first or second parameter!", V); 1419 SawSRet = true; 1420 } 1421 1422 if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) { 1423 Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!", 1424 V); 1425 } 1426 } 1427 1428 if (!Attrs.hasAttributes(AttributeSet::FunctionIndex)) 1429 return; 1430 1431 VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V); 1432 1433 Assert( 1434 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && 1435 Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)), 1436 "Attributes 'readnone and readonly' are incompatible!", V); 1437 1438 Assert( 1439 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) && 1440 Attrs.hasAttribute(AttributeSet::FunctionIndex, 1441 Attribute::AlwaysInline)), 1442 "Attributes 'noinline and alwaysinline' are incompatible!", V); 1443 1444 if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 1445 Attribute::OptimizeNone)) { 1446 Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline), 1447 "Attribute 'optnone' requires 'noinline'!", V); 1448 1449 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, 1450 Attribute::OptimizeForSize), 1451 "Attributes 'optsize and optnone' are incompatible!", V); 1452 1453 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize), 1454 "Attributes 'minsize and optnone' are incompatible!", V); 1455 } 1456 1457 if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 1458 Attribute::JumpTable)) { 1459 const GlobalValue *GV = cast<GlobalValue>(V); 1460 Assert(GV->hasUnnamedAddr(), 1461 "Attribute 'jumptable' requires 'unnamed_addr'", V); 1462 } 1463 } 1464 1465 void Verifier::VerifyConstantExprBitcastType(const ConstantExpr *CE) { 1466 if (CE->getOpcode() != Instruction::BitCast) 1467 return; 1468 1469 Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0), 1470 CE->getType()), 1471 "Invalid bitcast", CE); 1472 } 1473 1474 bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) { 1475 if (Attrs.getNumSlots() == 0) 1476 return true; 1477 1478 unsigned LastSlot = Attrs.getNumSlots() - 1; 1479 unsigned LastIndex = Attrs.getSlotIndex(LastSlot); 1480 if (LastIndex <= Params 1481 || (LastIndex == AttributeSet::FunctionIndex 1482 && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params))) 1483 return true; 1484 1485 return false; 1486 } 1487 1488 /// \brief Verify that statepoint intrinsic is well formed. 1489 void Verifier::VerifyStatepoint(ImmutableCallSite CS) { 1490 assert(CS.getCalledFunction() && 1491 CS.getCalledFunction()->getIntrinsicID() == 1492 Intrinsic::experimental_gc_statepoint); 1493 1494 const Instruction &CI = *CS.getInstruction(); 1495 1496 Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(), 1497 "gc.statepoint must read and write memory to preserve " 1498 "reordering restrictions required by safepoint semantics", 1499 &CI); 1500 1501 const Value *Target = CS.getArgument(0); 1502 const PointerType *PT = dyn_cast<PointerType>(Target->getType()); 1503 Assert(PT && PT->getElementType()->isFunctionTy(), 1504 "gc.statepoint callee must be of function pointer type", &CI, Target); 1505 FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType()); 1506 1507 const Value *NumCallArgsV = CS.getArgument(1); 1508 Assert(isa<ConstantInt>(NumCallArgsV), 1509 "gc.statepoint number of arguments to underlying call " 1510 "must be constant integer", 1511 &CI); 1512 const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue(); 1513 Assert(NumCallArgs >= 0, 1514 "gc.statepoint number of arguments to underlying call " 1515 "must be positive", 1516 &CI); 1517 const int NumParams = (int)TargetFuncType->getNumParams(); 1518 if (TargetFuncType->isVarArg()) { 1519 Assert(NumCallArgs >= NumParams, 1520 "gc.statepoint mismatch in number of vararg call args", &CI); 1521 1522 // TODO: Remove this limitation 1523 Assert(TargetFuncType->getReturnType()->isVoidTy(), 1524 "gc.statepoint doesn't support wrapping non-void " 1525 "vararg functions yet", 1526 &CI); 1527 } else 1528 Assert(NumCallArgs == NumParams, 1529 "gc.statepoint mismatch in number of call args", &CI); 1530 1531 const Value *Unused = CS.getArgument(2); 1532 Assert(isa<ConstantInt>(Unused) && cast<ConstantInt>(Unused)->isNullValue(), 1533 "gc.statepoint parameter #3 must be zero", &CI); 1534 1535 // Verify that the types of the call parameter arguments match 1536 // the type of the wrapped callee. 1537 for (int i = 0; i < NumParams; i++) { 1538 Type *ParamType = TargetFuncType->getParamType(i); 1539 Type *ArgType = CS.getArgument(3+i)->getType(); 1540 Assert(ArgType == ParamType, 1541 "gc.statepoint call argument does not match wrapped " 1542 "function type", 1543 &CI); 1544 } 1545 const int EndCallArgsInx = 2+NumCallArgs; 1546 const Value *NumDeoptArgsV = CS.getArgument(EndCallArgsInx+1); 1547 Assert(isa<ConstantInt>(NumDeoptArgsV), 1548 "gc.statepoint number of deoptimization arguments " 1549 "must be constant integer", 1550 &CI); 1551 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue(); 1552 Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments " 1553 "must be positive", 1554 &CI); 1555 1556 Assert(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(), 1557 "gc.statepoint too few arguments according to length fields", &CI); 1558 1559 // Check that the only uses of this gc.statepoint are gc.result or 1560 // gc.relocate calls which are tied to this statepoint and thus part 1561 // of the same statepoint sequence 1562 for (const User *U : CI.users()) { 1563 const CallInst *Call = dyn_cast<const CallInst>(U); 1564 Assert(Call, "illegal use of statepoint token", &CI, U); 1565 if (!Call) continue; 1566 Assert(isGCRelocate(Call) || isGCResult(Call), 1567 "gc.result or gc.relocate are the only value uses" 1568 "of a gc.statepoint", 1569 &CI, U); 1570 if (isGCResult(Call)) { 1571 Assert(Call->getArgOperand(0) == &CI, 1572 "gc.result connected to wrong gc.statepoint", &CI, Call); 1573 } else if (isGCRelocate(Call)) { 1574 Assert(Call->getArgOperand(0) == &CI, 1575 "gc.relocate connected to wrong gc.statepoint", &CI, Call); 1576 } 1577 } 1578 1579 // Note: It is legal for a single derived pointer to be listed multiple 1580 // times. It's non-optimal, but it is legal. It can also happen after 1581 // insertion if we strip a bitcast away. 1582 // Note: It is really tempting to check that each base is relocated and 1583 // that a derived pointer is never reused as a base pointer. This turns 1584 // out to be problematic since optimizations run after safepoint insertion 1585 // can recognize equality properties that the insertion logic doesn't know 1586 // about. See example statepoint.ll in the verifier subdirectory 1587 } 1588 1589 void Verifier::verifyFrameRecoverIndices() { 1590 for (auto &Counts : FrameEscapeInfo) { 1591 Function *F = Counts.first; 1592 unsigned EscapedObjectCount = Counts.second.first; 1593 unsigned MaxRecoveredIndex = Counts.second.second; 1594 Assert(MaxRecoveredIndex <= EscapedObjectCount, 1595 "all indices passed to llvm.framerecover must be less than the " 1596 "number of arguments passed ot llvm.frameescape in the parent " 1597 "function", 1598 F); 1599 } 1600 } 1601 1602 // visitFunction - Verify that a function is ok. 1603 // 1604 void Verifier::visitFunction(const Function &F) { 1605 // Check function arguments. 1606 FunctionType *FT = F.getFunctionType(); 1607 unsigned NumArgs = F.arg_size(); 1608 1609 Assert(Context == &F.getContext(), 1610 "Function context does not match Module context!", &F); 1611 1612 Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F); 1613 Assert(FT->getNumParams() == NumArgs, 1614 "# formal arguments must match # of arguments for function type!", &F, 1615 FT); 1616 Assert(F.getReturnType()->isFirstClassType() || 1617 F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(), 1618 "Functions cannot return aggregate values!", &F); 1619 1620 Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(), 1621 "Invalid struct return type!", &F); 1622 1623 AttributeSet Attrs = F.getAttributes(); 1624 1625 Assert(VerifyAttributeCount(Attrs, FT->getNumParams()), 1626 "Attribute after last parameter!", &F); 1627 1628 // Check function attributes. 1629 VerifyFunctionAttrs(FT, Attrs, &F); 1630 1631 // On function declarations/definitions, we do not support the builtin 1632 // attribute. We do not check this in VerifyFunctionAttrs since that is 1633 // checking for Attributes that can/can not ever be on functions. 1634 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin), 1635 "Attribute 'builtin' can only be applied to a callsite.", &F); 1636 1637 // Check that this function meets the restrictions on this calling convention. 1638 // Sometimes varargs is used for perfectly forwarding thunks, so some of these 1639 // restrictions can be lifted. 1640 switch (F.getCallingConv()) { 1641 default: 1642 case CallingConv::C: 1643 break; 1644 case CallingConv::Fast: 1645 case CallingConv::Cold: 1646 case CallingConv::Intel_OCL_BI: 1647 case CallingConv::PTX_Kernel: 1648 case CallingConv::PTX_Device: 1649 Assert(!F.isVarArg(), "Calling convention does not support varargs or " 1650 "perfect forwarding!", 1651 &F); 1652 break; 1653 } 1654 1655 bool isLLVMdotName = F.getName().size() >= 5 && 1656 F.getName().substr(0, 5) == "llvm."; 1657 1658 // Check that the argument values match the function type for this function... 1659 unsigned i = 0; 1660 for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; 1661 ++I, ++i) { 1662 Assert(I->getType() == FT->getParamType(i), 1663 "Argument value does not match function argument type!", I, 1664 FT->getParamType(i)); 1665 Assert(I->getType()->isFirstClassType(), 1666 "Function arguments must have first-class types!", I); 1667 if (!isLLVMdotName) 1668 Assert(!I->getType()->isMetadataTy(), 1669 "Function takes metadata but isn't an intrinsic", I, &F); 1670 } 1671 1672 if (F.isMaterializable()) { 1673 // Function has a body somewhere we can't see. 1674 } else if (F.isDeclaration()) { 1675 Assert(F.hasExternalLinkage() || F.hasExternalWeakLinkage(), 1676 "invalid linkage type for function declaration", &F); 1677 } else { 1678 // Verify that this function (which has a body) is not named "llvm.*". It 1679 // is not legal to define intrinsics. 1680 Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F); 1681 1682 // Check the entry node 1683 const BasicBlock *Entry = &F.getEntryBlock(); 1684 Assert(pred_empty(Entry), 1685 "Entry block to function must not have predecessors!", Entry); 1686 1687 // The address of the entry block cannot be taken, unless it is dead. 1688 if (Entry->hasAddressTaken()) { 1689 Assert(!BlockAddress::lookup(Entry)->isConstantUsed(), 1690 "blockaddress may not be used with the entry block!", Entry); 1691 } 1692 } 1693 1694 // If this function is actually an intrinsic, verify that it is only used in 1695 // direct call/invokes, never having its "address taken". 1696 if (F.getIntrinsicID()) { 1697 const User *U; 1698 if (F.hasAddressTaken(&U)) 1699 Assert(0, "Invalid user of intrinsic instruction!", U); 1700 } 1701 1702 Assert(!F.hasDLLImportStorageClass() || 1703 (F.isDeclaration() && F.hasExternalLinkage()) || 1704 F.hasAvailableExternallyLinkage(), 1705 "Function is marked as dllimport, but not external.", &F); 1706 } 1707 1708 // verifyBasicBlock - Verify that a basic block is well formed... 1709 // 1710 void Verifier::visitBasicBlock(BasicBlock &BB) { 1711 InstsInThisBlock.clear(); 1712 1713 // Ensure that basic blocks have terminators! 1714 Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB); 1715 1716 // Check constraints that this basic block imposes on all of the PHI nodes in 1717 // it. 1718 if (isa<PHINode>(BB.front())) { 1719 SmallVector<BasicBlock*, 8> Preds(pred_begin(&BB), pred_end(&BB)); 1720 SmallVector<std::pair<BasicBlock*, Value*>, 8> Values; 1721 std::sort(Preds.begin(), Preds.end()); 1722 PHINode *PN; 1723 for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) { 1724 // Ensure that PHI nodes have at least one entry! 1725 Assert(PN->getNumIncomingValues() != 0, 1726 "PHI nodes must have at least one entry. If the block is dead, " 1727 "the PHI should be removed!", 1728 PN); 1729 Assert(PN->getNumIncomingValues() == Preds.size(), 1730 "PHINode should have one entry for each predecessor of its " 1731 "parent basic block!", 1732 PN); 1733 1734 // Get and sort all incoming values in the PHI node... 1735 Values.clear(); 1736 Values.reserve(PN->getNumIncomingValues()); 1737 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 1738 Values.push_back(std::make_pair(PN->getIncomingBlock(i), 1739 PN->getIncomingValue(i))); 1740 std::sort(Values.begin(), Values.end()); 1741 1742 for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1743 // Check to make sure that if there is more than one entry for a 1744 // particular basic block in this PHI node, that the incoming values are 1745 // all identical. 1746 // 1747 Assert(i == 0 || Values[i].first != Values[i - 1].first || 1748 Values[i].second == Values[i - 1].second, 1749 "PHI node has multiple entries for the same basic block with " 1750 "different incoming values!", 1751 PN, Values[i].first, Values[i].second, Values[i - 1].second); 1752 1753 // Check to make sure that the predecessors and PHI node entries are 1754 // matched up. 1755 Assert(Values[i].first == Preds[i], 1756 "PHI node entries do not match predecessors!", PN, 1757 Values[i].first, Preds[i]); 1758 } 1759 } 1760 } 1761 1762 // Check that all instructions have their parent pointers set up correctly. 1763 for (auto &I : BB) 1764 { 1765 Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!"); 1766 } 1767 } 1768 1769 void Verifier::visitTerminatorInst(TerminatorInst &I) { 1770 // Ensure that terminators only exist at the end of the basic block. 1771 Assert(&I == I.getParent()->getTerminator(), 1772 "Terminator found in the middle of a basic block!", I.getParent()); 1773 visitInstruction(I); 1774 } 1775 1776 void Verifier::visitBranchInst(BranchInst &BI) { 1777 if (BI.isConditional()) { 1778 Assert(BI.getCondition()->getType()->isIntegerTy(1), 1779 "Branch condition is not 'i1' type!", &BI, BI.getCondition()); 1780 } 1781 visitTerminatorInst(BI); 1782 } 1783 1784 void Verifier::visitReturnInst(ReturnInst &RI) { 1785 Function *F = RI.getParent()->getParent(); 1786 unsigned N = RI.getNumOperands(); 1787 if (F->getReturnType()->isVoidTy()) 1788 Assert(N == 0, 1789 "Found return instr that returns non-void in Function of void " 1790 "return type!", 1791 &RI, F->getReturnType()); 1792 else 1793 Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(), 1794 "Function return type does not match operand " 1795 "type of return inst!", 1796 &RI, F->getReturnType()); 1797 1798 // Check to make sure that the return value has necessary properties for 1799 // terminators... 1800 visitTerminatorInst(RI); 1801 } 1802 1803 void Verifier::visitSwitchInst(SwitchInst &SI) { 1804 // Check to make sure that all of the constants in the switch instruction 1805 // have the same type as the switched-on value. 1806 Type *SwitchTy = SI.getCondition()->getType(); 1807 SmallPtrSet<ConstantInt*, 32> Constants; 1808 for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) { 1809 Assert(i.getCaseValue()->getType() == SwitchTy, 1810 "Switch constants must all be same type as switch value!", &SI); 1811 Assert(Constants.insert(i.getCaseValue()).second, 1812 "Duplicate integer as switch case", &SI, i.getCaseValue()); 1813 } 1814 1815 visitTerminatorInst(SI); 1816 } 1817 1818 void Verifier::visitIndirectBrInst(IndirectBrInst &BI) { 1819 Assert(BI.getAddress()->getType()->isPointerTy(), 1820 "Indirectbr operand must have pointer type!", &BI); 1821 for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i) 1822 Assert(BI.getDestination(i)->getType()->isLabelTy(), 1823 "Indirectbr destinations must all have pointer type!", &BI); 1824 1825 visitTerminatorInst(BI); 1826 } 1827 1828 void Verifier::visitSelectInst(SelectInst &SI) { 1829 Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1), 1830 SI.getOperand(2)), 1831 "Invalid operands for select instruction!", &SI); 1832 1833 Assert(SI.getTrueValue()->getType() == SI.getType(), 1834 "Select values must have same type as select instruction!", &SI); 1835 visitInstruction(SI); 1836 } 1837 1838 /// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of 1839 /// a pass, if any exist, it's an error. 1840 /// 1841 void Verifier::visitUserOp1(Instruction &I) { 1842 Assert(0, "User-defined operators should not live outside of a pass!", &I); 1843 } 1844 1845 void Verifier::visitTruncInst(TruncInst &I) { 1846 // Get the source and destination types 1847 Type *SrcTy = I.getOperand(0)->getType(); 1848 Type *DestTy = I.getType(); 1849 1850 // Get the size of the types in bits, we'll need this later 1851 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1852 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1853 1854 Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I); 1855 Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I); 1856 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1857 "trunc source and destination must both be a vector or neither", &I); 1858 Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I); 1859 1860 visitInstruction(I); 1861 } 1862 1863 void Verifier::visitZExtInst(ZExtInst &I) { 1864 // Get the source and destination types 1865 Type *SrcTy = I.getOperand(0)->getType(); 1866 Type *DestTy = I.getType(); 1867 1868 // Get the size of the types in bits, we'll need this later 1869 Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I); 1870 Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I); 1871 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1872 "zext source and destination must both be a vector or neither", &I); 1873 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1874 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1875 1876 Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I); 1877 1878 visitInstruction(I); 1879 } 1880 1881 void Verifier::visitSExtInst(SExtInst &I) { 1882 // Get the source and destination types 1883 Type *SrcTy = I.getOperand(0)->getType(); 1884 Type *DestTy = I.getType(); 1885 1886 // Get the size of the types in bits, we'll need this later 1887 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1888 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1889 1890 Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I); 1891 Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I); 1892 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1893 "sext source and destination must both be a vector or neither", &I); 1894 Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I); 1895 1896 visitInstruction(I); 1897 } 1898 1899 void Verifier::visitFPTruncInst(FPTruncInst &I) { 1900 // Get the source and destination types 1901 Type *SrcTy = I.getOperand(0)->getType(); 1902 Type *DestTy = I.getType(); 1903 // Get the size of the types in bits, we'll need this later 1904 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1905 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1906 1907 Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I); 1908 Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I); 1909 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1910 "fptrunc source and destination must both be a vector or neither", &I); 1911 Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I); 1912 1913 visitInstruction(I); 1914 } 1915 1916 void Verifier::visitFPExtInst(FPExtInst &I) { 1917 // Get the source and destination types 1918 Type *SrcTy = I.getOperand(0)->getType(); 1919 Type *DestTy = I.getType(); 1920 1921 // Get the size of the types in bits, we'll need this later 1922 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1923 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1924 1925 Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I); 1926 Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I); 1927 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1928 "fpext source and destination must both be a vector or neither", &I); 1929 Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I); 1930 1931 visitInstruction(I); 1932 } 1933 1934 void Verifier::visitUIToFPInst(UIToFPInst &I) { 1935 // Get the source and destination types 1936 Type *SrcTy = I.getOperand(0)->getType(); 1937 Type *DestTy = I.getType(); 1938 1939 bool SrcVec = SrcTy->isVectorTy(); 1940 bool DstVec = DestTy->isVectorTy(); 1941 1942 Assert(SrcVec == DstVec, 1943 "UIToFP source and dest must both be vector or scalar", &I); 1944 Assert(SrcTy->isIntOrIntVectorTy(), 1945 "UIToFP source must be integer or integer vector", &I); 1946 Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector", 1947 &I); 1948 1949 if (SrcVec && DstVec) 1950 Assert(cast<VectorType>(SrcTy)->getNumElements() == 1951 cast<VectorType>(DestTy)->getNumElements(), 1952 "UIToFP source and dest vector length mismatch", &I); 1953 1954 visitInstruction(I); 1955 } 1956 1957 void Verifier::visitSIToFPInst(SIToFPInst &I) { 1958 // Get the source and destination types 1959 Type *SrcTy = I.getOperand(0)->getType(); 1960 Type *DestTy = I.getType(); 1961 1962 bool SrcVec = SrcTy->isVectorTy(); 1963 bool DstVec = DestTy->isVectorTy(); 1964 1965 Assert(SrcVec == DstVec, 1966 "SIToFP source and dest must both be vector or scalar", &I); 1967 Assert(SrcTy->isIntOrIntVectorTy(), 1968 "SIToFP source must be integer or integer vector", &I); 1969 Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector", 1970 &I); 1971 1972 if (SrcVec && DstVec) 1973 Assert(cast<VectorType>(SrcTy)->getNumElements() == 1974 cast<VectorType>(DestTy)->getNumElements(), 1975 "SIToFP source and dest vector length mismatch", &I); 1976 1977 visitInstruction(I); 1978 } 1979 1980 void Verifier::visitFPToUIInst(FPToUIInst &I) { 1981 // Get the source and destination types 1982 Type *SrcTy = I.getOperand(0)->getType(); 1983 Type *DestTy = I.getType(); 1984 1985 bool SrcVec = SrcTy->isVectorTy(); 1986 bool DstVec = DestTy->isVectorTy(); 1987 1988 Assert(SrcVec == DstVec, 1989 "FPToUI source and dest must both be vector or scalar", &I); 1990 Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector", 1991 &I); 1992 Assert(DestTy->isIntOrIntVectorTy(), 1993 "FPToUI result must be integer or integer vector", &I); 1994 1995 if (SrcVec && DstVec) 1996 Assert(cast<VectorType>(SrcTy)->getNumElements() == 1997 cast<VectorType>(DestTy)->getNumElements(), 1998 "FPToUI source and dest vector length mismatch", &I); 1999 2000 visitInstruction(I); 2001 } 2002 2003 void Verifier::visitFPToSIInst(FPToSIInst &I) { 2004 // Get the source and destination types 2005 Type *SrcTy = I.getOperand(0)->getType(); 2006 Type *DestTy = I.getType(); 2007 2008 bool SrcVec = SrcTy->isVectorTy(); 2009 bool DstVec = DestTy->isVectorTy(); 2010 2011 Assert(SrcVec == DstVec, 2012 "FPToSI source and dest must both be vector or scalar", &I); 2013 Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector", 2014 &I); 2015 Assert(DestTy->isIntOrIntVectorTy(), 2016 "FPToSI result must be integer or integer vector", &I); 2017 2018 if (SrcVec && DstVec) 2019 Assert(cast<VectorType>(SrcTy)->getNumElements() == 2020 cast<VectorType>(DestTy)->getNumElements(), 2021 "FPToSI source and dest vector length mismatch", &I); 2022 2023 visitInstruction(I); 2024 } 2025 2026 void Verifier::visitPtrToIntInst(PtrToIntInst &I) { 2027 // Get the source and destination types 2028 Type *SrcTy = I.getOperand(0)->getType(); 2029 Type *DestTy = I.getType(); 2030 2031 Assert(SrcTy->getScalarType()->isPointerTy(), 2032 "PtrToInt source must be pointer", &I); 2033 Assert(DestTy->getScalarType()->isIntegerTy(), 2034 "PtrToInt result must be integral", &I); 2035 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch", 2036 &I); 2037 2038 if (SrcTy->isVectorTy()) { 2039 VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 2040 VectorType *VDest = dyn_cast<VectorType>(DestTy); 2041 Assert(VSrc->getNumElements() == VDest->getNumElements(), 2042 "PtrToInt Vector width mismatch", &I); 2043 } 2044 2045 visitInstruction(I); 2046 } 2047 2048 void Verifier::visitIntToPtrInst(IntToPtrInst &I) { 2049 // Get the source and destination types 2050 Type *SrcTy = I.getOperand(0)->getType(); 2051 Type *DestTy = I.getType(); 2052 2053 Assert(SrcTy->getScalarType()->isIntegerTy(), 2054 "IntToPtr source must be an integral", &I); 2055 Assert(DestTy->getScalarType()->isPointerTy(), 2056 "IntToPtr result must be a pointer", &I); 2057 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch", 2058 &I); 2059 if (SrcTy->isVectorTy()) { 2060 VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 2061 VectorType *VDest = dyn_cast<VectorType>(DestTy); 2062 Assert(VSrc->getNumElements() == VDest->getNumElements(), 2063 "IntToPtr Vector width mismatch", &I); 2064 } 2065 visitInstruction(I); 2066 } 2067 2068 void Verifier::visitBitCastInst(BitCastInst &I) { 2069 Assert( 2070 CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()), 2071 "Invalid bitcast", &I); 2072 visitInstruction(I); 2073 } 2074 2075 void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) { 2076 Type *SrcTy = I.getOperand(0)->getType(); 2077 Type *DestTy = I.getType(); 2078 2079 Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer", 2080 &I); 2081 Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer", 2082 &I); 2083 Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(), 2084 "AddrSpaceCast must be between different address spaces", &I); 2085 if (SrcTy->isVectorTy()) 2086 Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(), 2087 "AddrSpaceCast vector pointer number of elements mismatch", &I); 2088 visitInstruction(I); 2089 } 2090 2091 /// visitPHINode - Ensure that a PHI node is well formed. 2092 /// 2093 void Verifier::visitPHINode(PHINode &PN) { 2094 // Ensure that the PHI nodes are all grouped together at the top of the block. 2095 // This can be tested by checking whether the instruction before this is 2096 // either nonexistent (because this is begin()) or is a PHI node. If not, 2097 // then there is some other instruction before a PHI. 2098 Assert(&PN == &PN.getParent()->front() || 2099 isa<PHINode>(--BasicBlock::iterator(&PN)), 2100 "PHI nodes not grouped at top of basic block!", &PN, PN.getParent()); 2101 2102 // Check that all of the values of the PHI node have the same type as the 2103 // result, and that the incoming blocks are really basic blocks. 2104 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) { 2105 Assert(PN.getType() == PN.getIncomingValue(i)->getType(), 2106 "PHI node operands are not the same type as the result!", &PN); 2107 } 2108 2109 // All other PHI node constraints are checked in the visitBasicBlock method. 2110 2111 visitInstruction(PN); 2112 } 2113 2114 void Verifier::VerifyCallSite(CallSite CS) { 2115 Instruction *I = CS.getInstruction(); 2116 2117 Assert(CS.getCalledValue()->getType()->isPointerTy(), 2118 "Called function must be a pointer!", I); 2119 PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType()); 2120 2121 Assert(FPTy->getElementType()->isFunctionTy(), 2122 "Called function is not pointer to function type!", I); 2123 FunctionType *FTy = cast<FunctionType>(FPTy->getElementType()); 2124 2125 // Verify that the correct number of arguments are being passed 2126 if (FTy->isVarArg()) 2127 Assert(CS.arg_size() >= FTy->getNumParams(), 2128 "Called function requires more parameters than were provided!", I); 2129 else 2130 Assert(CS.arg_size() == FTy->getNumParams(), 2131 "Incorrect number of arguments passed to called function!", I); 2132 2133 // Verify that all arguments to the call match the function type. 2134 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) 2135 Assert(CS.getArgument(i)->getType() == FTy->getParamType(i), 2136 "Call parameter type does not match function signature!", 2137 CS.getArgument(i), FTy->getParamType(i), I); 2138 2139 AttributeSet Attrs = CS.getAttributes(); 2140 2141 Assert(VerifyAttributeCount(Attrs, CS.arg_size()), 2142 "Attribute after last parameter!", I); 2143 2144 // Verify call attributes. 2145 VerifyFunctionAttrs(FTy, Attrs, I); 2146 2147 // Conservatively check the inalloca argument. 2148 // We have a bug if we can find that there is an underlying alloca without 2149 // inalloca. 2150 if (CS.hasInAllocaArgument()) { 2151 Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1); 2152 if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets())) 2153 Assert(AI->isUsedWithInAlloca(), 2154 "inalloca argument for call has mismatched alloca", AI, I); 2155 } 2156 2157 if (FTy->isVarArg()) { 2158 // FIXME? is 'nest' even legal here? 2159 bool SawNest = false; 2160 bool SawReturned = false; 2161 2162 for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) { 2163 if (Attrs.hasAttribute(Idx, Attribute::Nest)) 2164 SawNest = true; 2165 if (Attrs.hasAttribute(Idx, Attribute::Returned)) 2166 SawReturned = true; 2167 } 2168 2169 // Check attributes on the varargs part. 2170 for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { 2171 Type *Ty = CS.getArgument(Idx-1)->getType(); 2172 VerifyParameterAttrs(Attrs, Idx, Ty, false, I); 2173 2174 if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 2175 Assert(!SawNest, "More than one parameter has attribute nest!", I); 2176 SawNest = true; 2177 } 2178 2179 if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 2180 Assert(!SawReturned, "More than one parameter has attribute returned!", 2181 I); 2182 Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()), 2183 "Incompatible argument and return types for 'returned' " 2184 "attribute", 2185 I); 2186 SawReturned = true; 2187 } 2188 2189 Assert(!Attrs.hasAttribute(Idx, Attribute::StructRet), 2190 "Attribute 'sret' cannot be used for vararg call arguments!", I); 2191 2192 if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) 2193 Assert(Idx == CS.arg_size(), "inalloca isn't on the last argument!", I); 2194 } 2195 } 2196 2197 // Verify that there's no metadata unless it's a direct call to an intrinsic. 2198 if (CS.getCalledFunction() == nullptr || 2199 !CS.getCalledFunction()->getName().startswith("llvm.")) { 2200 for (FunctionType::param_iterator PI = FTy->param_begin(), 2201 PE = FTy->param_end(); PI != PE; ++PI) 2202 Assert(!(*PI)->isMetadataTy(), 2203 "Function has metadata parameter but isn't an intrinsic", I); 2204 } 2205 2206 visitInstruction(*I); 2207 } 2208 2209 /// Two types are "congruent" if they are identical, or if they are both pointer 2210 /// types with different pointee types and the same address space. 2211 static bool isTypeCongruent(Type *L, Type *R) { 2212 if (L == R) 2213 return true; 2214 PointerType *PL = dyn_cast<PointerType>(L); 2215 PointerType *PR = dyn_cast<PointerType>(R); 2216 if (!PL || !PR) 2217 return false; 2218 return PL->getAddressSpace() == PR->getAddressSpace(); 2219 } 2220 2221 static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs) { 2222 static const Attribute::AttrKind ABIAttrs[] = { 2223 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, 2224 Attribute::InReg, Attribute::Returned}; 2225 AttrBuilder Copy; 2226 for (auto AK : ABIAttrs) { 2227 if (Attrs.hasAttribute(I + 1, AK)) 2228 Copy.addAttribute(AK); 2229 } 2230 if (Attrs.hasAttribute(I + 1, Attribute::Alignment)) 2231 Copy.addAlignmentAttr(Attrs.getParamAlignment(I + 1)); 2232 return Copy; 2233 } 2234 2235 void Verifier::verifyMustTailCall(CallInst &CI) { 2236 Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI); 2237 2238 // - The caller and callee prototypes must match. Pointer types of 2239 // parameters or return types may differ in pointee type, but not 2240 // address space. 2241 Function *F = CI.getParent()->getParent(); 2242 auto GetFnTy = [](Value *V) { 2243 return cast<FunctionType>( 2244 cast<PointerType>(V->getType())->getElementType()); 2245 }; 2246 FunctionType *CallerTy = GetFnTy(F); 2247 FunctionType *CalleeTy = GetFnTy(CI.getCalledValue()); 2248 Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(), 2249 "cannot guarantee tail call due to mismatched parameter counts", &CI); 2250 Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(), 2251 "cannot guarantee tail call due to mismatched varargs", &CI); 2252 Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()), 2253 "cannot guarantee tail call due to mismatched return types", &CI); 2254 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) { 2255 Assert( 2256 isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)), 2257 "cannot guarantee tail call due to mismatched parameter types", &CI); 2258 } 2259 2260 // - The calling conventions of the caller and callee must match. 2261 Assert(F->getCallingConv() == CI.getCallingConv(), 2262 "cannot guarantee tail call due to mismatched calling conv", &CI); 2263 2264 // - All ABI-impacting function attributes, such as sret, byval, inreg, 2265 // returned, and inalloca, must match. 2266 AttributeSet CallerAttrs = F->getAttributes(); 2267 AttributeSet CalleeAttrs = CI.getAttributes(); 2268 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) { 2269 AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs); 2270 AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs); 2271 Assert(CallerABIAttrs == CalleeABIAttrs, 2272 "cannot guarantee tail call due to mismatched ABI impacting " 2273 "function attributes", 2274 &CI, CI.getOperand(I)); 2275 } 2276 2277 // - The call must immediately precede a :ref:`ret <i_ret>` instruction, 2278 // or a pointer bitcast followed by a ret instruction. 2279 // - The ret instruction must return the (possibly bitcasted) value 2280 // produced by the call or void. 2281 Value *RetVal = &CI; 2282 Instruction *Next = CI.getNextNode(); 2283 2284 // Handle the optional bitcast. 2285 if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) { 2286 Assert(BI->getOperand(0) == RetVal, 2287 "bitcast following musttail call must use the call", BI); 2288 RetVal = BI; 2289 Next = BI->getNextNode(); 2290 } 2291 2292 // Check the return. 2293 ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next); 2294 Assert(Ret, "musttail call must be precede a ret with an optional bitcast", 2295 &CI); 2296 Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal, 2297 "musttail call result must be returned", Ret); 2298 } 2299 2300 void Verifier::visitCallInst(CallInst &CI) { 2301 VerifyCallSite(&CI); 2302 2303 if (CI.isMustTailCall()) 2304 verifyMustTailCall(CI); 2305 2306 if (Function *F = CI.getCalledFunction()) 2307 if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) 2308 visitIntrinsicFunctionCall(ID, CI); 2309 } 2310 2311 void Verifier::visitInvokeInst(InvokeInst &II) { 2312 VerifyCallSite(&II); 2313 2314 // Verify that there is a landingpad instruction as the first non-PHI 2315 // instruction of the 'unwind' destination. 2316 Assert(II.getUnwindDest()->isLandingPad(), 2317 "The unwind destination does not have a landingpad instruction!", &II); 2318 2319 if (Function *F = II.getCalledFunction()) 2320 // TODO: Ideally we should use visitIntrinsicFunction here. But it uses 2321 // CallInst as an input parameter. It not woth updating this whole 2322 // function only to support statepoint verification. 2323 if (F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint) 2324 VerifyStatepoint(ImmutableCallSite(&II)); 2325 2326 visitTerminatorInst(II); 2327 } 2328 2329 /// visitBinaryOperator - Check that both arguments to the binary operator are 2330 /// of the same type! 2331 /// 2332 void Verifier::visitBinaryOperator(BinaryOperator &B) { 2333 Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(), 2334 "Both operands to a binary operator are not of the same type!", &B); 2335 2336 switch (B.getOpcode()) { 2337 // Check that integer arithmetic operators are only used with 2338 // integral operands. 2339 case Instruction::Add: 2340 case Instruction::Sub: 2341 case Instruction::Mul: 2342 case Instruction::SDiv: 2343 case Instruction::UDiv: 2344 case Instruction::SRem: 2345 case Instruction::URem: 2346 Assert(B.getType()->isIntOrIntVectorTy(), 2347 "Integer arithmetic operators only work with integral types!", &B); 2348 Assert(B.getType() == B.getOperand(0)->getType(), 2349 "Integer arithmetic operators must have same type " 2350 "for operands and result!", 2351 &B); 2352 break; 2353 // Check that floating-point arithmetic operators are only used with 2354 // floating-point operands. 2355 case Instruction::FAdd: 2356 case Instruction::FSub: 2357 case Instruction::FMul: 2358 case Instruction::FDiv: 2359 case Instruction::FRem: 2360 Assert(B.getType()->isFPOrFPVectorTy(), 2361 "Floating-point arithmetic operators only work with " 2362 "floating-point types!", 2363 &B); 2364 Assert(B.getType() == B.getOperand(0)->getType(), 2365 "Floating-point arithmetic operators must have same type " 2366 "for operands and result!", 2367 &B); 2368 break; 2369 // Check that logical operators are only used with integral operands. 2370 case Instruction::And: 2371 case Instruction::Or: 2372 case Instruction::Xor: 2373 Assert(B.getType()->isIntOrIntVectorTy(), 2374 "Logical operators only work with integral types!", &B); 2375 Assert(B.getType() == B.getOperand(0)->getType(), 2376 "Logical operators must have same type for operands and result!", 2377 &B); 2378 break; 2379 case Instruction::Shl: 2380 case Instruction::LShr: 2381 case Instruction::AShr: 2382 Assert(B.getType()->isIntOrIntVectorTy(), 2383 "Shifts only work with integral types!", &B); 2384 Assert(B.getType() == B.getOperand(0)->getType(), 2385 "Shift return type must be same as operands!", &B); 2386 break; 2387 default: 2388 llvm_unreachable("Unknown BinaryOperator opcode!"); 2389 } 2390 2391 visitInstruction(B); 2392 } 2393 2394 void Verifier::visitICmpInst(ICmpInst &IC) { 2395 // Check that the operands are the same type 2396 Type *Op0Ty = IC.getOperand(0)->getType(); 2397 Type *Op1Ty = IC.getOperand(1)->getType(); 2398 Assert(Op0Ty == Op1Ty, 2399 "Both operands to ICmp instruction are not of the same type!", &IC); 2400 // Check that the operands are the right type 2401 Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(), 2402 "Invalid operand types for ICmp instruction", &IC); 2403 // Check that the predicate is valid. 2404 Assert(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE && 2405 IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE, 2406 "Invalid predicate in ICmp instruction!", &IC); 2407 2408 visitInstruction(IC); 2409 } 2410 2411 void Verifier::visitFCmpInst(FCmpInst &FC) { 2412 // Check that the operands are the same type 2413 Type *Op0Ty = FC.getOperand(0)->getType(); 2414 Type *Op1Ty = FC.getOperand(1)->getType(); 2415 Assert(Op0Ty == Op1Ty, 2416 "Both operands to FCmp instruction are not of the same type!", &FC); 2417 // Check that the operands are the right type 2418 Assert(Op0Ty->isFPOrFPVectorTy(), 2419 "Invalid operand types for FCmp instruction", &FC); 2420 // Check that the predicate is valid. 2421 Assert(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE && 2422 FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE, 2423 "Invalid predicate in FCmp instruction!", &FC); 2424 2425 visitInstruction(FC); 2426 } 2427 2428 void Verifier::visitExtractElementInst(ExtractElementInst &EI) { 2429 Assert( 2430 ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)), 2431 "Invalid extractelement operands!", &EI); 2432 visitInstruction(EI); 2433 } 2434 2435 void Verifier::visitInsertElementInst(InsertElementInst &IE) { 2436 Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1), 2437 IE.getOperand(2)), 2438 "Invalid insertelement operands!", &IE); 2439 visitInstruction(IE); 2440 } 2441 2442 void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { 2443 Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1), 2444 SV.getOperand(2)), 2445 "Invalid shufflevector operands!", &SV); 2446 visitInstruction(SV); 2447 } 2448 2449 void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { 2450 Type *TargetTy = GEP.getPointerOperandType()->getScalarType(); 2451 2452 Assert(isa<PointerType>(TargetTy), 2453 "GEP base pointer is not a vector or a vector of pointers", &GEP); 2454 Assert(cast<PointerType>(TargetTy)->getElementType()->isSized(), 2455 "GEP into unsized type!", &GEP); 2456 Assert(GEP.getPointerOperandType()->isVectorTy() == 2457 GEP.getType()->isVectorTy(), 2458 "Vector GEP must return a vector value", &GEP); 2459 2460 SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end()); 2461 Type *ElTy = 2462 GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs); 2463 Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP); 2464 2465 Assert(GEP.getType()->getScalarType()->isPointerTy() && 2466 cast<PointerType>(GEP.getType()->getScalarType()) 2467 ->getElementType() == ElTy, 2468 "GEP is not of right type for indices!", &GEP, ElTy); 2469 2470 if (GEP.getPointerOperandType()->isVectorTy()) { 2471 // Additional checks for vector GEPs. 2472 unsigned GepWidth = GEP.getPointerOperandType()->getVectorNumElements(); 2473 Assert(GepWidth == GEP.getType()->getVectorNumElements(), 2474 "Vector GEP result width doesn't match operand's", &GEP); 2475 for (unsigned i = 0, e = Idxs.size(); i != e; ++i) { 2476 Type *IndexTy = Idxs[i]->getType(); 2477 Assert(IndexTy->isVectorTy(), "Vector GEP must have vector indices!", 2478 &GEP); 2479 unsigned IndexWidth = IndexTy->getVectorNumElements(); 2480 Assert(IndexWidth == GepWidth, "Invalid GEP index vector width", &GEP); 2481 } 2482 } 2483 visitInstruction(GEP); 2484 } 2485 2486 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) { 2487 return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); 2488 } 2489 2490 void Verifier::visitRangeMetadata(Instruction& I, 2491 MDNode* Range, Type* Ty) { 2492 assert(Range && 2493 Range == I.getMetadata(LLVMContext::MD_range) && 2494 "precondition violation"); 2495 2496 unsigned NumOperands = Range->getNumOperands(); 2497 Assert(NumOperands % 2 == 0, "Unfinished range!", Range); 2498 unsigned NumRanges = NumOperands / 2; 2499 Assert(NumRanges >= 1, "It should have at least one range!", Range); 2500 2501 ConstantRange LastRange(1); // Dummy initial value 2502 for (unsigned i = 0; i < NumRanges; ++i) { 2503 ConstantInt *Low = 2504 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i)); 2505 Assert(Low, "The lower limit must be an integer!", Low); 2506 ConstantInt *High = 2507 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1)); 2508 Assert(High, "The upper limit must be an integer!", High); 2509 Assert(High->getType() == Low->getType() && High->getType() == Ty, 2510 "Range types must match instruction type!", &I); 2511 2512 APInt HighV = High->getValue(); 2513 APInt LowV = Low->getValue(); 2514 ConstantRange CurRange(LowV, HighV); 2515 Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(), 2516 "Range must not be empty!", Range); 2517 if (i != 0) { 2518 Assert(CurRange.intersectWith(LastRange).isEmptySet(), 2519 "Intervals are overlapping", Range); 2520 Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order", 2521 Range); 2522 Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous", 2523 Range); 2524 } 2525 LastRange = ConstantRange(LowV, HighV); 2526 } 2527 if (NumRanges > 2) { 2528 APInt FirstLow = 2529 mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue(); 2530 APInt FirstHigh = 2531 mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue(); 2532 ConstantRange FirstRange(FirstLow, FirstHigh); 2533 Assert(FirstRange.intersectWith(LastRange).isEmptySet(), 2534 "Intervals are overlapping", Range); 2535 Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous", 2536 Range); 2537 } 2538 } 2539 2540 void Verifier::visitLoadInst(LoadInst &LI) { 2541 PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType()); 2542 Assert(PTy, "Load operand must be a pointer.", &LI); 2543 Type *ElTy = LI.getType(); 2544 Assert(LI.getAlignment() <= Value::MaximumAlignment, 2545 "huge alignment values are unsupported", &LI); 2546 if (LI.isAtomic()) { 2547 Assert(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease, 2548 "Load cannot have Release ordering", &LI); 2549 Assert(LI.getAlignment() != 0, 2550 "Atomic load must specify explicit alignment", &LI); 2551 if (!ElTy->isPointerTy()) { 2552 Assert(ElTy->isIntegerTy(), "atomic load operand must have integer type!", 2553 &LI, ElTy); 2554 unsigned Size = ElTy->getPrimitiveSizeInBits(); 2555 Assert(Size >= 8 && !(Size & (Size - 1)), 2556 "atomic load operand must be power-of-two byte-sized integer", &LI, 2557 ElTy); 2558 } 2559 } else { 2560 Assert(LI.getSynchScope() == CrossThread, 2561 "Non-atomic load cannot have SynchronizationScope specified", &LI); 2562 } 2563 2564 visitInstruction(LI); 2565 } 2566 2567 void Verifier::visitStoreInst(StoreInst &SI) { 2568 PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType()); 2569 Assert(PTy, "Store operand must be a pointer.", &SI); 2570 Type *ElTy = PTy->getElementType(); 2571 Assert(ElTy == SI.getOperand(0)->getType(), 2572 "Stored value type does not match pointer operand type!", &SI, ElTy); 2573 Assert(SI.getAlignment() <= Value::MaximumAlignment, 2574 "huge alignment values are unsupported", &SI); 2575 if (SI.isAtomic()) { 2576 Assert(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease, 2577 "Store cannot have Acquire ordering", &SI); 2578 Assert(SI.getAlignment() != 0, 2579 "Atomic store must specify explicit alignment", &SI); 2580 if (!ElTy->isPointerTy()) { 2581 Assert(ElTy->isIntegerTy(), 2582 "atomic store operand must have integer type!", &SI, ElTy); 2583 unsigned Size = ElTy->getPrimitiveSizeInBits(); 2584 Assert(Size >= 8 && !(Size & (Size - 1)), 2585 "atomic store operand must be power-of-two byte-sized integer", 2586 &SI, ElTy); 2587 } 2588 } else { 2589 Assert(SI.getSynchScope() == CrossThread, 2590 "Non-atomic store cannot have SynchronizationScope specified", &SI); 2591 } 2592 visitInstruction(SI); 2593 } 2594 2595 void Verifier::visitAllocaInst(AllocaInst &AI) { 2596 SmallPtrSet<const Type*, 4> Visited; 2597 PointerType *PTy = AI.getType(); 2598 Assert(PTy->getAddressSpace() == 0, 2599 "Allocation instruction pointer not in the generic address space!", 2600 &AI); 2601 Assert(PTy->getElementType()->isSized(&Visited), 2602 "Cannot allocate unsized type", &AI); 2603 Assert(AI.getArraySize()->getType()->isIntegerTy(), 2604 "Alloca array size must have integer type", &AI); 2605 Assert(AI.getAlignment() <= Value::MaximumAlignment, 2606 "huge alignment values are unsupported", &AI); 2607 2608 visitInstruction(AI); 2609 } 2610 2611 void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) { 2612 2613 // FIXME: more conditions??? 2614 Assert(CXI.getSuccessOrdering() != NotAtomic, 2615 "cmpxchg instructions must be atomic.", &CXI); 2616 Assert(CXI.getFailureOrdering() != NotAtomic, 2617 "cmpxchg instructions must be atomic.", &CXI); 2618 Assert(CXI.getSuccessOrdering() != Unordered, 2619 "cmpxchg instructions cannot be unordered.", &CXI); 2620 Assert(CXI.getFailureOrdering() != Unordered, 2621 "cmpxchg instructions cannot be unordered.", &CXI); 2622 Assert(CXI.getSuccessOrdering() >= CXI.getFailureOrdering(), 2623 "cmpxchg instructions be at least as constrained on success as fail", 2624 &CXI); 2625 Assert(CXI.getFailureOrdering() != Release && 2626 CXI.getFailureOrdering() != AcquireRelease, 2627 "cmpxchg failure ordering cannot include release semantics", &CXI); 2628 2629 PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType()); 2630 Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI); 2631 Type *ElTy = PTy->getElementType(); 2632 Assert(ElTy->isIntegerTy(), "cmpxchg operand must have integer type!", &CXI, 2633 ElTy); 2634 unsigned Size = ElTy->getPrimitiveSizeInBits(); 2635 Assert(Size >= 8 && !(Size & (Size - 1)), 2636 "cmpxchg operand must be power-of-two byte-sized integer", &CXI, ElTy); 2637 Assert(ElTy == CXI.getOperand(1)->getType(), 2638 "Expected value type does not match pointer operand type!", &CXI, 2639 ElTy); 2640 Assert(ElTy == CXI.getOperand(2)->getType(), 2641 "Stored value type does not match pointer operand type!", &CXI, ElTy); 2642 visitInstruction(CXI); 2643 } 2644 2645 void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) { 2646 Assert(RMWI.getOrdering() != NotAtomic, 2647 "atomicrmw instructions must be atomic.", &RMWI); 2648 Assert(RMWI.getOrdering() != Unordered, 2649 "atomicrmw instructions cannot be unordered.", &RMWI); 2650 PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType()); 2651 Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI); 2652 Type *ElTy = PTy->getElementType(); 2653 Assert(ElTy->isIntegerTy(), "atomicrmw operand must have integer type!", 2654 &RMWI, ElTy); 2655 unsigned Size = ElTy->getPrimitiveSizeInBits(); 2656 Assert(Size >= 8 && !(Size & (Size - 1)), 2657 "atomicrmw operand must be power-of-two byte-sized integer", &RMWI, 2658 ElTy); 2659 Assert(ElTy == RMWI.getOperand(1)->getType(), 2660 "Argument value type does not match pointer operand type!", &RMWI, 2661 ElTy); 2662 Assert(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() && 2663 RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP, 2664 "Invalid binary operation!", &RMWI); 2665 visitInstruction(RMWI); 2666 } 2667 2668 void Verifier::visitFenceInst(FenceInst &FI) { 2669 const AtomicOrdering Ordering = FI.getOrdering(); 2670 Assert(Ordering == Acquire || Ordering == Release || 2671 Ordering == AcquireRelease || Ordering == SequentiallyConsistent, 2672 "fence instructions may only have " 2673 "acquire, release, acq_rel, or seq_cst ordering.", 2674 &FI); 2675 visitInstruction(FI); 2676 } 2677 2678 void Verifier::visitExtractValueInst(ExtractValueInst &EVI) { 2679 Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(), 2680 EVI.getIndices()) == EVI.getType(), 2681 "Invalid ExtractValueInst operands!", &EVI); 2682 2683 visitInstruction(EVI); 2684 } 2685 2686 void Verifier::visitInsertValueInst(InsertValueInst &IVI) { 2687 Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(), 2688 IVI.getIndices()) == 2689 IVI.getOperand(1)->getType(), 2690 "Invalid InsertValueInst operands!", &IVI); 2691 2692 visitInstruction(IVI); 2693 } 2694 2695 void Verifier::visitLandingPadInst(LandingPadInst &LPI) { 2696 BasicBlock *BB = LPI.getParent(); 2697 2698 // The landingpad instruction is ill-formed if it doesn't have any clauses and 2699 // isn't a cleanup. 2700 Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(), 2701 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI); 2702 2703 // The landingpad instruction defines its parent as a landing pad block. The 2704 // landing pad block may be branched to only by the unwind edge of an invoke. 2705 for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) { 2706 const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator()); 2707 Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB, 2708 "Block containing LandingPadInst must be jumped to " 2709 "only by the unwind edge of an invoke.", 2710 &LPI); 2711 } 2712 2713 // The landingpad instruction must be the first non-PHI instruction in the 2714 // block. 2715 Assert(LPI.getParent()->getLandingPadInst() == &LPI, 2716 "LandingPadInst not the first non-PHI instruction in the block.", 2717 &LPI); 2718 2719 // The personality functions for all landingpad instructions within the same 2720 // function should match. 2721 if (PersonalityFn) 2722 Assert(LPI.getPersonalityFn() == PersonalityFn, 2723 "Personality function doesn't match others in function", &LPI); 2724 PersonalityFn = LPI.getPersonalityFn(); 2725 2726 // All operands must be constants. 2727 Assert(isa<Constant>(PersonalityFn), "Personality function is not constant!", 2728 &LPI); 2729 for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) { 2730 Constant *Clause = LPI.getClause(i); 2731 if (LPI.isCatch(i)) { 2732 Assert(isa<PointerType>(Clause->getType()), 2733 "Catch operand does not have pointer type!", &LPI); 2734 } else { 2735 Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI); 2736 Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause), 2737 "Filter operand is not an array of constants!", &LPI); 2738 } 2739 } 2740 2741 visitInstruction(LPI); 2742 } 2743 2744 void Verifier::verifyDominatesUse(Instruction &I, unsigned i) { 2745 Instruction *Op = cast<Instruction>(I.getOperand(i)); 2746 // If the we have an invalid invoke, don't try to compute the dominance. 2747 // We already reject it in the invoke specific checks and the dominance 2748 // computation doesn't handle multiple edges. 2749 if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) { 2750 if (II->getNormalDest() == II->getUnwindDest()) 2751 return; 2752 } 2753 2754 const Use &U = I.getOperandUse(i); 2755 Assert(InstsInThisBlock.count(Op) || DT.dominates(Op, U), 2756 "Instruction does not dominate all uses!", Op, &I); 2757 } 2758 2759 /// verifyInstruction - Verify that an instruction is well formed. 2760 /// 2761 void Verifier::visitInstruction(Instruction &I) { 2762 BasicBlock *BB = I.getParent(); 2763 Assert(BB, "Instruction not embedded in basic block!", &I); 2764 2765 if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential 2766 for (User *U : I.users()) { 2767 Assert(U != (User *)&I || !DT.isReachableFromEntry(BB), 2768 "Only PHI nodes may reference their own value!", &I); 2769 } 2770 } 2771 2772 // Check that void typed values don't have names 2773 Assert(!I.getType()->isVoidTy() || !I.hasName(), 2774 "Instruction has a name, but provides a void value!", &I); 2775 2776 // Check that the return value of the instruction is either void or a legal 2777 // value type. 2778 Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(), 2779 "Instruction returns a non-scalar type!", &I); 2780 2781 // Check that the instruction doesn't produce metadata. Calls are already 2782 // checked against the callee type. 2783 Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I), 2784 "Invalid use of metadata!", &I); 2785 2786 // Check that all uses of the instruction, if they are instructions 2787 // themselves, actually have parent basic blocks. If the use is not an 2788 // instruction, it is an error! 2789 for (Use &U : I.uses()) { 2790 if (Instruction *Used = dyn_cast<Instruction>(U.getUser())) 2791 Assert(Used->getParent() != nullptr, 2792 "Instruction referencing" 2793 " instruction not embedded in a basic block!", 2794 &I, Used); 2795 else { 2796 CheckFailed("Use of instruction is not an instruction!", U); 2797 return; 2798 } 2799 } 2800 2801 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 2802 Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I); 2803 2804 // Check to make sure that only first-class-values are operands to 2805 // instructions. 2806 if (!I.getOperand(i)->getType()->isFirstClassType()) { 2807 Assert(0, "Instruction operands must be first-class values!", &I); 2808 } 2809 2810 if (Function *F = dyn_cast<Function>(I.getOperand(i))) { 2811 // Check to make sure that the "address of" an intrinsic function is never 2812 // taken. 2813 Assert( 2814 !F->isIntrinsic() || 2815 i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0), 2816 "Cannot take the address of an intrinsic!", &I); 2817 Assert( 2818 !F->isIntrinsic() || isa<CallInst>(I) || 2819 F->getIntrinsicID() == Intrinsic::donothing || 2820 F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void || 2821 F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 || 2822 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint, 2823 "Cannot invoke an intrinsinc other than" 2824 " donothing or patchpoint", 2825 &I); 2826 Assert(F->getParent() == M, "Referencing function in another module!", 2827 &I); 2828 } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) { 2829 Assert(OpBB->getParent() == BB->getParent(), 2830 "Referring to a basic block in another function!", &I); 2831 } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) { 2832 Assert(OpArg->getParent() == BB->getParent(), 2833 "Referring to an argument in another function!", &I); 2834 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) { 2835 Assert(GV->getParent() == M, "Referencing global in another module!", &I); 2836 } else if (isa<Instruction>(I.getOperand(i))) { 2837 verifyDominatesUse(I, i); 2838 } else if (isa<InlineAsm>(I.getOperand(i))) { 2839 Assert((i + 1 == e && isa<CallInst>(I)) || 2840 (i + 3 == e && isa<InvokeInst>(I)), 2841 "Cannot take the address of an inline asm!", &I); 2842 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) { 2843 if (CE->getType()->isPtrOrPtrVectorTy()) { 2844 // If we have a ConstantExpr pointer, we need to see if it came from an 2845 // illegal bitcast (inttoptr <constant int> ) 2846 SmallVector<const ConstantExpr *, 4> Stack; 2847 SmallPtrSet<const ConstantExpr *, 4> Visited; 2848 Stack.push_back(CE); 2849 2850 while (!Stack.empty()) { 2851 const ConstantExpr *V = Stack.pop_back_val(); 2852 if (!Visited.insert(V).second) 2853 continue; 2854 2855 VerifyConstantExprBitcastType(V); 2856 2857 for (unsigned I = 0, N = V->getNumOperands(); I != N; ++I) { 2858 if (ConstantExpr *Op = dyn_cast<ConstantExpr>(V->getOperand(I))) 2859 Stack.push_back(Op); 2860 } 2861 } 2862 } 2863 } 2864 } 2865 2866 if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) { 2867 Assert(I.getType()->isFPOrFPVectorTy(), 2868 "fpmath requires a floating point result!", &I); 2869 Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I); 2870 if (ConstantFP *CFP0 = 2871 mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) { 2872 APFloat Accuracy = CFP0->getValueAPF(); 2873 Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(), 2874 "fpmath accuracy not a positive number!", &I); 2875 } else { 2876 Assert(false, "invalid fpmath accuracy!", &I); 2877 } 2878 } 2879 2880 if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) { 2881 Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I), 2882 "Ranges are only for loads, calls and invokes!", &I); 2883 visitRangeMetadata(I, Range, I.getType()); 2884 } 2885 2886 if (I.getMetadata(LLVMContext::MD_nonnull)) { 2887 Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types", 2888 &I); 2889 Assert(isa<LoadInst>(I), 2890 "nonnull applies only to load instructions, use attributes" 2891 " for calls or invokes", 2892 &I); 2893 } 2894 2895 if (MDNode *N = I.getDebugLoc().getAsMDNode()) { 2896 Assert(isa<MDLocation>(N), "invalid !dbg metadata attachment", &I, N); 2897 visitMDNode(*N); 2898 } 2899 2900 InstsInThisBlock.insert(&I); 2901 } 2902 2903 /// VerifyIntrinsicType - Verify that the specified type (which comes from an 2904 /// intrinsic argument or return value) matches the type constraints specified 2905 /// by the .td file (e.g. an "any integer" argument really is an integer). 2906 /// 2907 /// This return true on error but does not print a message. 2908 bool Verifier::VerifyIntrinsicType(Type *Ty, 2909 ArrayRef<Intrinsic::IITDescriptor> &Infos, 2910 SmallVectorImpl<Type*> &ArgTys) { 2911 using namespace Intrinsic; 2912 2913 // If we ran out of descriptors, there are too many arguments. 2914 if (Infos.empty()) return true; 2915 IITDescriptor D = Infos.front(); 2916 Infos = Infos.slice(1); 2917 2918 switch (D.Kind) { 2919 case IITDescriptor::Void: return !Ty->isVoidTy(); 2920 case IITDescriptor::VarArg: return true; 2921 case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); 2922 case IITDescriptor::Metadata: return !Ty->isMetadataTy(); 2923 case IITDescriptor::Half: return !Ty->isHalfTy(); 2924 case IITDescriptor::Float: return !Ty->isFloatTy(); 2925 case IITDescriptor::Double: return !Ty->isDoubleTy(); 2926 case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width); 2927 case IITDescriptor::Vector: { 2928 VectorType *VT = dyn_cast<VectorType>(Ty); 2929 return !VT || VT->getNumElements() != D.Vector_Width || 2930 VerifyIntrinsicType(VT->getElementType(), Infos, ArgTys); 2931 } 2932 case IITDescriptor::Pointer: { 2933 PointerType *PT = dyn_cast<PointerType>(Ty); 2934 return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace || 2935 VerifyIntrinsicType(PT->getElementType(), Infos, ArgTys); 2936 } 2937 2938 case IITDescriptor::Struct: { 2939 StructType *ST = dyn_cast<StructType>(Ty); 2940 if (!ST || ST->getNumElements() != D.Struct_NumElements) 2941 return true; 2942 2943 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 2944 if (VerifyIntrinsicType(ST->getElementType(i), Infos, ArgTys)) 2945 return true; 2946 return false; 2947 } 2948 2949 case IITDescriptor::Argument: 2950 // Two cases here - If this is the second occurrence of an argument, verify 2951 // that the later instance matches the previous instance. 2952 if (D.getArgumentNumber() < ArgTys.size()) 2953 return Ty != ArgTys[D.getArgumentNumber()]; 2954 2955 // Otherwise, if this is the first instance of an argument, record it and 2956 // verify the "Any" kind. 2957 assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error"); 2958 ArgTys.push_back(Ty); 2959 2960 switch (D.getArgumentKind()) { 2961 case IITDescriptor::AK_Any: return false; // Success 2962 case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy(); 2963 case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy(); 2964 case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty); 2965 case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty); 2966 } 2967 llvm_unreachable("all argument kinds not covered"); 2968 2969 case IITDescriptor::ExtendArgument: { 2970 // This may only be used when referring to a previous vector argument. 2971 if (D.getArgumentNumber() >= ArgTys.size()) 2972 return true; 2973 2974 Type *NewTy = ArgTys[D.getArgumentNumber()]; 2975 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 2976 NewTy = VectorType::getExtendedElementVectorType(VTy); 2977 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 2978 NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth()); 2979 else 2980 return true; 2981 2982 return Ty != NewTy; 2983 } 2984 case IITDescriptor::TruncArgument: { 2985 // This may only be used when referring to a previous vector argument. 2986 if (D.getArgumentNumber() >= ArgTys.size()) 2987 return true; 2988 2989 Type *NewTy = ArgTys[D.getArgumentNumber()]; 2990 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 2991 NewTy = VectorType::getTruncatedElementVectorType(VTy); 2992 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 2993 NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2); 2994 else 2995 return true; 2996 2997 return Ty != NewTy; 2998 } 2999 case IITDescriptor::HalfVecArgument: 3000 // This may only be used when referring to a previous vector argument. 3001 return D.getArgumentNumber() >= ArgTys.size() || 3002 !isa<VectorType>(ArgTys[D.getArgumentNumber()]) || 3003 VectorType::getHalfElementsVectorType( 3004 cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty; 3005 case IITDescriptor::SameVecWidthArgument: { 3006 if (D.getArgumentNumber() >= ArgTys.size()) 3007 return true; 3008 VectorType * ReferenceType = 3009 dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]); 3010 VectorType *ThisArgType = dyn_cast<VectorType>(Ty); 3011 if (!ThisArgType || !ReferenceType || 3012 (ReferenceType->getVectorNumElements() != 3013 ThisArgType->getVectorNumElements())) 3014 return true; 3015 return VerifyIntrinsicType(ThisArgType->getVectorElementType(), 3016 Infos, ArgTys); 3017 } 3018 case IITDescriptor::PtrToArgument: { 3019 if (D.getArgumentNumber() >= ArgTys.size()) 3020 return true; 3021 Type * ReferenceType = ArgTys[D.getArgumentNumber()]; 3022 PointerType *ThisArgType = dyn_cast<PointerType>(Ty); 3023 return (!ThisArgType || ThisArgType->getElementType() != ReferenceType); 3024 } 3025 case IITDescriptor::VecOfPtrsToElt: { 3026 if (D.getArgumentNumber() >= ArgTys.size()) 3027 return true; 3028 VectorType * ReferenceType = 3029 dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]); 3030 VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty); 3031 if (!ThisArgVecTy || !ReferenceType || 3032 (ReferenceType->getVectorNumElements() != 3033 ThisArgVecTy->getVectorNumElements())) 3034 return true; 3035 PointerType *ThisArgEltTy = 3036 dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType()); 3037 if (!ThisArgEltTy) 3038 return true; 3039 return (!(ThisArgEltTy->getElementType() == 3040 ReferenceType->getVectorElementType())); 3041 } 3042 } 3043 llvm_unreachable("unhandled"); 3044 } 3045 3046 /// \brief Verify if the intrinsic has variable arguments. 3047 /// This method is intended to be called after all the fixed arguments have been 3048 /// verified first. 3049 /// 3050 /// This method returns true on error and does not print an error message. 3051 bool 3052 Verifier::VerifyIntrinsicIsVarArg(bool isVarArg, 3053 ArrayRef<Intrinsic::IITDescriptor> &Infos) { 3054 using namespace Intrinsic; 3055 3056 // If there are no descriptors left, then it can't be a vararg. 3057 if (Infos.empty()) 3058 return isVarArg; 3059 3060 // There should be only one descriptor remaining at this point. 3061 if (Infos.size() != 1) 3062 return true; 3063 3064 // Check and verify the descriptor. 3065 IITDescriptor D = Infos.front(); 3066 Infos = Infos.slice(1); 3067 if (D.Kind == IITDescriptor::VarArg) 3068 return !isVarArg; 3069 3070 return true; 3071 } 3072 3073 /// visitIntrinsicFunction - Allow intrinsics to be verified in different ways. 3074 /// 3075 void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { 3076 Function *IF = CI.getCalledFunction(); 3077 Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!", 3078 IF); 3079 3080 // Verify that the intrinsic prototype lines up with what the .td files 3081 // describe. 3082 FunctionType *IFTy = IF->getFunctionType(); 3083 bool IsVarArg = IFTy->isVarArg(); 3084 3085 SmallVector<Intrinsic::IITDescriptor, 8> Table; 3086 getIntrinsicInfoTableEntries(ID, Table); 3087 ArrayRef<Intrinsic::IITDescriptor> TableRef = Table; 3088 3089 SmallVector<Type *, 4> ArgTys; 3090 Assert(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys), 3091 "Intrinsic has incorrect return type!", IF); 3092 for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i) 3093 Assert(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys), 3094 "Intrinsic has incorrect argument type!", IF); 3095 3096 // Verify if the intrinsic call matches the vararg property. 3097 if (IsVarArg) 3098 Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 3099 "Intrinsic was not defined with variable arguments!", IF); 3100 else 3101 Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 3102 "Callsite was not defined with variable arguments!", IF); 3103 3104 // All descriptors should be absorbed by now. 3105 Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF); 3106 3107 // Now that we have the intrinsic ID and the actual argument types (and we 3108 // know they are legal for the intrinsic!) get the intrinsic name through the 3109 // usual means. This allows us to verify the mangling of argument types into 3110 // the name. 3111 const std::string ExpectedName = Intrinsic::getName(ID, ArgTys); 3112 Assert(ExpectedName == IF->getName(), 3113 "Intrinsic name not mangled correctly for type arguments! " 3114 "Should be: " + 3115 ExpectedName, 3116 IF); 3117 3118 // If the intrinsic takes MDNode arguments, verify that they are either global 3119 // or are local to *this* function. 3120 for (unsigned i = 0, e = CI.getNumArgOperands(); i != e; ++i) 3121 if (auto *MD = dyn_cast<MetadataAsValue>(CI.getArgOperand(i))) 3122 visitMetadataAsValue(*MD, CI.getParent()->getParent()); 3123 3124 switch (ID) { 3125 default: 3126 break; 3127 case Intrinsic::ctlz: // llvm.ctlz 3128 case Intrinsic::cttz: // llvm.cttz 3129 Assert(isa<ConstantInt>(CI.getArgOperand(1)), 3130 "is_zero_undef argument of bit counting intrinsics must be a " 3131 "constant int", 3132 &CI); 3133 break; 3134 case Intrinsic::dbg_declare: // llvm.dbg.declare 3135 Assert(isa<MetadataAsValue>(CI.getArgOperand(0)), 3136 "invalid llvm.dbg.declare intrinsic call 1", &CI); 3137 visitDbgIntrinsic("declare", cast<DbgDeclareInst>(CI)); 3138 break; 3139 case Intrinsic::dbg_value: // llvm.dbg.value 3140 visitDbgIntrinsic("value", cast<DbgValueInst>(CI)); 3141 break; 3142 case Intrinsic::memcpy: 3143 case Intrinsic::memmove: 3144 case Intrinsic::memset: { 3145 ConstantInt *AlignCI = dyn_cast<ConstantInt>(CI.getArgOperand(3)); 3146 Assert(AlignCI, 3147 "alignment argument of memory intrinsics must be a constant int", 3148 &CI); 3149 const APInt &AlignVal = AlignCI->getValue(); 3150 Assert(AlignCI->isZero() || AlignVal.isPowerOf2(), 3151 "alignment argument of memory intrinsics must be a power of 2", &CI); 3152 Assert(isa<ConstantInt>(CI.getArgOperand(4)), 3153 "isvolatile argument of memory intrinsics must be a constant int", 3154 &CI); 3155 break; 3156 } 3157 case Intrinsic::gcroot: 3158 case Intrinsic::gcwrite: 3159 case Intrinsic::gcread: 3160 if (ID == Intrinsic::gcroot) { 3161 AllocaInst *AI = 3162 dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts()); 3163 Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI); 3164 Assert(isa<Constant>(CI.getArgOperand(1)), 3165 "llvm.gcroot parameter #2 must be a constant.", &CI); 3166 if (!AI->getType()->getElementType()->isPointerTy()) { 3167 Assert(!isa<ConstantPointerNull>(CI.getArgOperand(1)), 3168 "llvm.gcroot parameter #1 must either be a pointer alloca, " 3169 "or argument #2 must be a non-null constant.", 3170 &CI); 3171 } 3172 } 3173 3174 Assert(CI.getParent()->getParent()->hasGC(), 3175 "Enclosing function does not use GC.", &CI); 3176 break; 3177 case Intrinsic::init_trampoline: 3178 Assert(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()), 3179 "llvm.init_trampoline parameter #2 must resolve to a function.", 3180 &CI); 3181 break; 3182 case Intrinsic::prefetch: 3183 Assert(isa<ConstantInt>(CI.getArgOperand(1)) && 3184 isa<ConstantInt>(CI.getArgOperand(2)) && 3185 cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 && 3186 cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4, 3187 "invalid arguments to llvm.prefetch", &CI); 3188 break; 3189 case Intrinsic::stackprotector: 3190 Assert(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()), 3191 "llvm.stackprotector parameter #2 must resolve to an alloca.", &CI); 3192 break; 3193 case Intrinsic::lifetime_start: 3194 case Intrinsic::lifetime_end: 3195 case Intrinsic::invariant_start: 3196 Assert(isa<ConstantInt>(CI.getArgOperand(0)), 3197 "size argument of memory use markers must be a constant integer", 3198 &CI); 3199 break; 3200 case Intrinsic::invariant_end: 3201 Assert(isa<ConstantInt>(CI.getArgOperand(1)), 3202 "llvm.invariant.end parameter #2 must be a constant integer", &CI); 3203 break; 3204 3205 case Intrinsic::frameescape: { 3206 BasicBlock *BB = CI.getParent(); 3207 Assert(BB == &BB->getParent()->front(), 3208 "llvm.frameescape used outside of entry block", &CI); 3209 Assert(!SawFrameEscape, 3210 "multiple calls to llvm.frameescape in one function", &CI); 3211 for (Value *Arg : CI.arg_operands()) { 3212 if (isa<ConstantPointerNull>(Arg)) 3213 continue; // Null values are allowed as placeholders. 3214 auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts()); 3215 Assert(AI && AI->isStaticAlloca(), 3216 "llvm.frameescape only accepts static allocas", &CI); 3217 } 3218 FrameEscapeInfo[BB->getParent()].first = CI.getNumArgOperands(); 3219 SawFrameEscape = true; 3220 break; 3221 } 3222 case Intrinsic::framerecover: { 3223 Value *FnArg = CI.getArgOperand(0)->stripPointerCasts(); 3224 Function *Fn = dyn_cast<Function>(FnArg); 3225 Assert(Fn && !Fn->isDeclaration(), 3226 "llvm.framerecover first " 3227 "argument must be function defined in this module", 3228 &CI); 3229 auto *IdxArg = dyn_cast<ConstantInt>(CI.getArgOperand(2)); 3230 Assert(IdxArg, "idx argument of llvm.framerecover must be a constant int", 3231 &CI); 3232 auto &Entry = FrameEscapeInfo[Fn]; 3233 Entry.second = unsigned( 3234 std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1)); 3235 break; 3236 } 3237 3238 case Intrinsic::experimental_gc_statepoint: 3239 Assert(!CI.isInlineAsm(), 3240 "gc.statepoint support for inline assembly unimplemented", &CI); 3241 Assert(CI.getParent()->getParent()->hasGC(), 3242 "Enclosing function does not use GC.", &CI); 3243 3244 VerifyStatepoint(ImmutableCallSite(&CI)); 3245 break; 3246 case Intrinsic::experimental_gc_result_int: 3247 case Intrinsic::experimental_gc_result_float: 3248 case Intrinsic::experimental_gc_result_ptr: 3249 case Intrinsic::experimental_gc_result: { 3250 Assert(CI.getParent()->getParent()->hasGC(), 3251 "Enclosing function does not use GC.", &CI); 3252 // Are we tied to a statepoint properly? 3253 CallSite StatepointCS(CI.getArgOperand(0)); 3254 const Function *StatepointFn = 3255 StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr; 3256 Assert(StatepointFn && StatepointFn->isDeclaration() && 3257 StatepointFn->getIntrinsicID() == 3258 Intrinsic::experimental_gc_statepoint, 3259 "gc.result operand #1 must be from a statepoint", &CI, 3260 CI.getArgOperand(0)); 3261 3262 // Assert that result type matches wrapped callee. 3263 const Value *Target = StatepointCS.getArgument(0); 3264 const PointerType *PT = cast<PointerType>(Target->getType()); 3265 const FunctionType *TargetFuncType = 3266 cast<FunctionType>(PT->getElementType()); 3267 Assert(CI.getType() == TargetFuncType->getReturnType(), 3268 "gc.result result type does not match wrapped callee", &CI); 3269 break; 3270 } 3271 case Intrinsic::experimental_gc_relocate: { 3272 Assert(CI.getNumArgOperands() == 3, "wrong number of arguments", &CI); 3273 3274 // Check that this relocate is correctly tied to the statepoint 3275 3276 // This is case for relocate on the unwinding path of an invoke statepoint 3277 if (ExtractValueInst *ExtractValue = 3278 dyn_cast<ExtractValueInst>(CI.getArgOperand(0))) { 3279 Assert(isa<LandingPadInst>(ExtractValue->getAggregateOperand()), 3280 "gc relocate on unwind path incorrectly linked to the statepoint", 3281 &CI); 3282 3283 const BasicBlock *invokeBB = 3284 ExtractValue->getParent()->getUniquePredecessor(); 3285 3286 // Landingpad relocates should have only one predecessor with invoke 3287 // statepoint terminator 3288 Assert(invokeBB, "safepoints should have unique landingpads", 3289 ExtractValue->getParent()); 3290 Assert(invokeBB->getTerminator(), "safepoint block should be well formed", 3291 invokeBB); 3292 Assert(isStatepoint(invokeBB->getTerminator()), 3293 "gc relocate should be linked to a statepoint", invokeBB); 3294 } 3295 else { 3296 // In all other cases relocate should be tied to the statepoint directly. 3297 // This covers relocates on a normal return path of invoke statepoint and 3298 // relocates of a call statepoint 3299 auto Token = CI.getArgOperand(0); 3300 Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)), 3301 "gc relocate is incorrectly tied to the statepoint", &CI, Token); 3302 } 3303 3304 // Verify rest of the relocate arguments 3305 3306 GCRelocateOperands ops(&CI); 3307 ImmutableCallSite StatepointCS(ops.statepoint()); 3308 3309 // Both the base and derived must be piped through the safepoint 3310 Value* Base = CI.getArgOperand(1); 3311 Assert(isa<ConstantInt>(Base), 3312 "gc.relocate operand #2 must be integer offset", &CI); 3313 3314 Value* Derived = CI.getArgOperand(2); 3315 Assert(isa<ConstantInt>(Derived), 3316 "gc.relocate operand #3 must be integer offset", &CI); 3317 3318 const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue(); 3319 const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue(); 3320 // Check the bounds 3321 Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(), 3322 "gc.relocate: statepoint base index out of bounds", &CI); 3323 Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(), 3324 "gc.relocate: statepoint derived index out of bounds", &CI); 3325 3326 // Check that BaseIndex and DerivedIndex fall within the 'gc parameters' 3327 // section of the statepoint's argument 3328 Assert(StatepointCS.arg_size() > 0, 3329 "gc.statepoint: insufficient arguments"); 3330 Assert(isa<ConstantInt>(StatepointCS.getArgument(1)), 3331 "gc.statement: number of call arguments must be constant integer"); 3332 const unsigned NumCallArgs = 3333 cast<ConstantInt>(StatepointCS.getArgument(1))->getZExtValue(); 3334 Assert(StatepointCS.arg_size() > NumCallArgs+3, 3335 "gc.statepoint: mismatch in number of call arguments"); 3336 Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs+3)), 3337 "gc.statepoint: number of deoptimization arguments must be " 3338 "a constant integer"); 3339 const int NumDeoptArgs = 3340 cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 3))->getZExtValue(); 3341 const int GCParamArgsStart = NumCallArgs + NumDeoptArgs + 4; 3342 const int GCParamArgsEnd = StatepointCS.arg_size(); 3343 Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd, 3344 "gc.relocate: statepoint base index doesn't fall within the " 3345 "'gc parameters' section of the statepoint call", 3346 &CI); 3347 Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd, 3348 "gc.relocate: statepoint derived index doesn't fall within the " 3349 "'gc parameters' section of the statepoint call", 3350 &CI); 3351 3352 // Assert that the result type matches the type of the relocated pointer 3353 GCRelocateOperands Operands(&CI); 3354 Assert(Operands.derivedPtr()->getType() == CI.getType(), 3355 "gc.relocate: relocating a pointer shouldn't change its type", &CI); 3356 break; 3357 } 3358 }; 3359 } 3360 3361 /// \brief Carefully grab the subprogram from a local scope. 3362 /// 3363 /// This carefully grabs the subprogram from a local scope, avoiding the 3364 /// built-in assertions that would typically fire. 3365 static MDSubprogram *getSubprogram(Metadata *LocalScope) { 3366 if (!LocalScope) 3367 return nullptr; 3368 3369 if (auto *SP = dyn_cast<MDSubprogram>(LocalScope)) 3370 return SP; 3371 3372 if (auto *LB = dyn_cast<MDLexicalBlockBase>(LocalScope)) 3373 return getSubprogram(LB->getRawScope()); 3374 3375 // Just return null; broken scope chains are checked elsewhere. 3376 assert(!isa<MDLocalScope>(LocalScope) && "Unknown type of local scope"); 3377 return nullptr; 3378 } 3379 3380 template <class DbgIntrinsicTy> 3381 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) { 3382 auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata(); 3383 Assert(isa<ValueAsMetadata>(MD) || 3384 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()), 3385 "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD); 3386 Assert(isa<MDLocalVariable>(DII.getRawVariable()), 3387 "invalid llvm.dbg." + Kind + " intrinsic variable", &DII, 3388 DII.getRawVariable()); 3389 Assert(isa<MDExpression>(DII.getRawExpression()), 3390 "invalid llvm.dbg." + Kind + " intrinsic expression", &DII, 3391 DII.getRawExpression()); 3392 3393 // Ignore broken !dbg attachments; they're checked elsewhere. 3394 if (MDNode *N = DII.getDebugLoc().getAsMDNode()) 3395 if (!isa<MDLocation>(N)) 3396 return; 3397 3398 BasicBlock *BB = DII.getParent(); 3399 Function *F = BB ? BB->getParent() : nullptr; 3400 3401 // The scopes for variables and !dbg attachments must agree. 3402 MDLocalVariable *Var = DII.getVariable(); 3403 MDLocation *Loc = DII.getDebugLoc(); 3404 Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment", 3405 &DII, BB, F); 3406 3407 MDSubprogram *VarSP = getSubprogram(Var->getRawScope()); 3408 MDSubprogram *LocSP = getSubprogram(Loc->getRawScope()); 3409 if (!VarSP || !LocSP) 3410 return; // Broken scope chains are checked elsewhere. 3411 3412 Assert(VarSP == LocSP, "mismatched subprogram between llvm.dbg." + Kind + 3413 " variable and !dbg attachment", 3414 &DII, BB, F, Var, Var->getScope()->getSubprogram(), Loc, 3415 Loc->getScope()->getSubprogram()); 3416 } 3417 3418 template <class MapTy> 3419 static uint64_t getVariableSize(const MDLocalVariable &V, const MapTy &Map) { 3420 // Be careful of broken types (checked elsewhere). 3421 const Metadata *RawType = V.getRawType(); 3422 while (RawType) { 3423 // Try to get the size directly. 3424 if (auto *T = dyn_cast<MDType>(RawType)) 3425 if (uint64_t Size = T->getSizeInBits()) 3426 return Size; 3427 3428 if (auto *DT = dyn_cast<MDDerivedType>(RawType)) { 3429 // Look at the base type. 3430 RawType = DT->getRawBaseType(); 3431 continue; 3432 } 3433 3434 if (auto *S = dyn_cast<MDString>(RawType)) { 3435 // Don't error on missing types (checked elsewhere). 3436 RawType = Map.lookup(S); 3437 continue; 3438 } 3439 3440 // Missing type or size. 3441 break; 3442 } 3443 3444 // Fail gracefully. 3445 return 0; 3446 } 3447 3448 template <class MapTy> 3449 void Verifier::verifyBitPieceExpression(const DbgInfoIntrinsic &I, 3450 const MapTy &TypeRefs) { 3451 MDLocalVariable *V; 3452 MDExpression *E; 3453 if (auto *DVI = dyn_cast<DbgValueInst>(&I)) { 3454 V = dyn_cast_or_null<MDLocalVariable>(DVI->getRawVariable()); 3455 E = dyn_cast_or_null<MDExpression>(DVI->getRawExpression()); 3456 } else { 3457 auto *DDI = cast<DbgDeclareInst>(&I); 3458 V = dyn_cast_or_null<MDLocalVariable>(DDI->getRawVariable()); 3459 E = dyn_cast_or_null<MDExpression>(DDI->getRawExpression()); 3460 } 3461 3462 // We don't know whether this intrinsic verified correctly. 3463 if (!V || !E || !E->isValid()) 3464 return; 3465 3466 // Nothing to do if this isn't a bit piece expression. 3467 if (!E->isBitPiece()) 3468 return; 3469 3470 // If there's no size, the type is broken, but that should be checked 3471 // elsewhere. 3472 uint64_t VarSize = getVariableSize(*V, TypeRefs); 3473 if (!VarSize) 3474 return; 3475 3476 unsigned PieceSize = E->getBitPieceSize(); 3477 unsigned PieceOffset = E->getBitPieceOffset(); 3478 Assert(PieceSize + PieceOffset <= VarSize, 3479 "piece is larger than or outside of variable", &I, V, E); 3480 Assert(PieceSize != VarSize, "piece covers entire variable", &I, V, E); 3481 } 3482 3483 void Verifier::visitUnresolvedTypeRef(const MDString *S, const MDNode *N) { 3484 // This is in its own function so we get an error for each bad type ref (not 3485 // just the first). 3486 Assert(false, "unresolved type ref", S, N); 3487 } 3488 3489 void Verifier::verifyTypeRefs() { 3490 auto *CUs = M->getNamedMetadata("llvm.dbg.cu"); 3491 if (!CUs) 3492 return; 3493 3494 // Visit all the compile units again to map the type references. 3495 SmallDenseMap<const MDString *, const MDType *, 32> TypeRefs; 3496 for (auto *CU : CUs->operands()) 3497 if (auto Ts = cast<MDCompileUnit>(CU)->getRetainedTypes()) 3498 for (MDType *Op : Ts) 3499 if (auto *T = dyn_cast<MDCompositeType>(Op)) 3500 if (auto *S = T->getRawIdentifier()) { 3501 UnresolvedTypeRefs.erase(S); 3502 TypeRefs.insert(std::make_pair(S, T)); 3503 } 3504 3505 // Verify debug info intrinsic bit piece expressions. This needs a second 3506 // pass through the intructions, since we haven't built TypeRefs yet when 3507 // verifying functions, and simply queuing the DbgInfoIntrinsics to evaluate 3508 // later/now would queue up some that could be later deleted. 3509 for (const Function &F : *M) 3510 for (const BasicBlock &BB : F) 3511 for (const Instruction &I : BB) 3512 if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I)) 3513 verifyBitPieceExpression(*DII, TypeRefs); 3514 3515 // Return early if all typerefs were resolved. 3516 if (UnresolvedTypeRefs.empty()) 3517 return; 3518 3519 // Sort the unresolved references by name so the output is deterministic. 3520 typedef std::pair<const MDString *, const MDNode *> TypeRef; 3521 SmallVector<TypeRef, 32> Unresolved(UnresolvedTypeRefs.begin(), 3522 UnresolvedTypeRefs.end()); 3523 std::sort(Unresolved.begin(), Unresolved.end(), 3524 [](const TypeRef &LHS, const TypeRef &RHS) { 3525 return LHS.first->getString() < RHS.first->getString(); 3526 }); 3527 3528 // Visit the unresolved refs (printing out the errors). 3529 for (const TypeRef &TR : Unresolved) 3530 visitUnresolvedTypeRef(TR.first, TR.second); 3531 } 3532 3533 //===----------------------------------------------------------------------===// 3534 // Implement the public interfaces to this file... 3535 //===----------------------------------------------------------------------===// 3536 3537 bool llvm::verifyFunction(const Function &f, raw_ostream *OS) { 3538 Function &F = const_cast<Function &>(f); 3539 assert(!F.isDeclaration() && "Cannot verify external functions"); 3540 3541 raw_null_ostream NullStr; 3542 Verifier V(OS ? *OS : NullStr); 3543 3544 // Note that this function's return value is inverted from what you would 3545 // expect of a function called "verify". 3546 return !V.verify(F); 3547 } 3548 3549 bool llvm::verifyModule(const Module &M, raw_ostream *OS) { 3550 raw_null_ostream NullStr; 3551 Verifier V(OS ? *OS : NullStr); 3552 3553 bool Broken = false; 3554 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) 3555 if (!I->isDeclaration() && !I->isMaterializable()) 3556 Broken |= !V.verify(*I); 3557 3558 // Note that this function's return value is inverted from what you would 3559 // expect of a function called "verify". 3560 return !V.verify(M) || Broken; 3561 } 3562 3563 namespace { 3564 struct VerifierLegacyPass : public FunctionPass { 3565 static char ID; 3566 3567 Verifier V; 3568 bool FatalErrors; 3569 3570 VerifierLegacyPass() : FunctionPass(ID), V(dbgs()), FatalErrors(true) { 3571 initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry()); 3572 } 3573 explicit VerifierLegacyPass(bool FatalErrors) 3574 : FunctionPass(ID), V(dbgs()), FatalErrors(FatalErrors) { 3575 initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry()); 3576 } 3577 3578 bool runOnFunction(Function &F) override { 3579 if (!V.verify(F) && FatalErrors) 3580 report_fatal_error("Broken function found, compilation aborted!"); 3581 3582 return false; 3583 } 3584 3585 bool doFinalization(Module &M) override { 3586 if (!V.verify(M) && FatalErrors) 3587 report_fatal_error("Broken module found, compilation aborted!"); 3588 3589 return false; 3590 } 3591 3592 void getAnalysisUsage(AnalysisUsage &AU) const override { 3593 AU.setPreservesAll(); 3594 } 3595 }; 3596 } 3597 3598 char VerifierLegacyPass::ID = 0; 3599 INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false) 3600 3601 FunctionPass *llvm::createVerifierPass(bool FatalErrors) { 3602 return new VerifierLegacyPass(FatalErrors); 3603 } 3604 3605 PreservedAnalyses VerifierPass::run(Module &M) { 3606 if (verifyModule(M, &dbgs()) && FatalErrors) 3607 report_fatal_error("Broken module found, compilation aborted!"); 3608 3609 return PreservedAnalyses::all(); 3610 } 3611 3612 PreservedAnalyses VerifierPass::run(Function &F) { 3613 if (verifyFunction(F, &dbgs()) && FatalErrors) 3614 report_fatal_error("Broken function found, compilation aborted!"); 3615 3616 return PreservedAnalyses::all(); 3617 } 3618