Verifier.cpp revision 296417
1//===-- Verifier.cpp - Implement the Module Verifier -----------------------==// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the function verifier interface, that can be used for some 11// sanity checking of input to the system. 12// 13// Note that this does not provide full `Java style' security and verifications, 14// instead it just tries to ensure that code is well-formed. 15// 16// * Both of a binary operator's parameters are of the same type 17// * Verify that the indices of mem access instructions match other operands 18// * Verify that arithmetic and other things are only performed on first-class 19// types. Verify that shifts & logicals only happen on integrals f.e. 20// * All of the constants in a switch statement are of the correct type 21// * The code is in valid SSA form 22// * It should be illegal to put a label into any other type (like a structure) 23// or to return one. [except constant arrays!] 24// * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad 25// * PHI nodes must have an entry for each predecessor, with no extras. 26// * PHI nodes must be the first thing in a basic block, all grouped together 27// * PHI nodes must have at least one entry 28// * All basic blocks should only end with terminator insts, not contain them 29// * The entry node to a function must not have predecessors 30// * All Instructions must be embedded into a basic block 31// * Functions cannot take a void-typed parameter 32// * Verify that a function's argument list agrees with it's declared type. 33// * It is illegal to specify a name for a void value. 34// * It is illegal to have a internal global value with no initializer 35// * It is illegal to have a ret instruction that returns a value that does not 36// agree with the function return value type. 37// * Function call argument types match the function prototype 38// * A landing pad is defined by a landingpad instruction, and can be jumped to 39// only by the unwind edge of an invoke instruction. 40// * A landingpad instruction must be the first non-PHI instruction in the 41// block. 42// * Landingpad instructions must be in a function with a personality function. 43// * All other things that are tested by asserts spread about the code... 44// 45//===----------------------------------------------------------------------===// 46 47#include "llvm/IR/Verifier.h" 48#include "llvm/ADT/MapVector.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> 79using namespace llvm; 80 81static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true)); 82 83namespace { 84struct 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 94private: 95 template <class NodeTy> void Write(const ilist_iterator<NodeTy> &I) { 96 Write(&*I); 97 } 98 99 void Write(const Module *M) { 100 if (!M) 101 return; 102 OS << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 103 } 104 105 void Write(const Value *V) { 106 if (!V) 107 return; 108 if (isa<Instruction>(V)) { 109 OS << *V << '\n'; 110 } else { 111 V->printAsOperand(OS, true, M); 112 OS << '\n'; 113 } 114 } 115 void Write(ImmutableCallSite CS) { 116 Write(CS.getInstruction()); 117 } 118 119 void Write(const Metadata *MD) { 120 if (!MD) 121 return; 122 MD->print(OS, M); 123 OS << '\n'; 124 } 125 126 template <class T> void Write(const MDTupleTypedArrayWrapper<T> &MD) { 127 Write(MD.get()); 128 } 129 130 void Write(const NamedMDNode *NMD) { 131 if (!NMD) 132 return; 133 NMD->print(OS); 134 OS << '\n'; 135 } 136 137 void Write(Type *T) { 138 if (!T) 139 return; 140 OS << ' ' << *T; 141 } 142 143 void Write(const Comdat *C) { 144 if (!C) 145 return; 146 OS << *C; 147 } 148 149 template <typename T> void Write(ArrayRef<T> Vs) { 150 for (const T &V : Vs) 151 Write(V); 152 } 153 154 template <typename T1, typename... Ts> 155 void WriteTs(const T1 &V1, const Ts &... Vs) { 156 Write(V1); 157 WriteTs(Vs...); 158 } 159 160 template <typename... Ts> void WriteTs() {} 161 162public: 163 /// \brief A check failed, so printout out the condition and the message. 164 /// 165 /// This provides a nice place to put a breakpoint if you want to see why 166 /// something is not correct. 167 void CheckFailed(const Twine &Message) { 168 OS << Message << '\n'; 169 Broken = true; 170 } 171 172 /// \brief A check failed (with values to print). 173 /// 174 /// This calls the Message-only version so that the above is easier to set a 175 /// breakpoint on. 176 template <typename T1, typename... Ts> 177 void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) { 178 CheckFailed(Message); 179 WriteTs(V1, Vs...); 180 } 181}; 182 183class Verifier : public InstVisitor<Verifier>, VerifierSupport { 184 friend class InstVisitor<Verifier>; 185 186 LLVMContext *Context; 187 DominatorTree DT; 188 189 /// \brief When verifying a basic block, keep track of all of the 190 /// instructions we have seen so far. 191 /// 192 /// This allows us to do efficient dominance checks for the case when an 193 /// instruction has an operand that is an instruction in the same block. 194 SmallPtrSet<Instruction *, 16> InstsInThisBlock; 195 196 /// \brief Keep track of the metadata nodes that have been checked already. 197 SmallPtrSet<const Metadata *, 32> MDNodes; 198 199 /// \brief Track unresolved string-based type references. 200 SmallDenseMap<const MDString *, const MDNode *, 32> UnresolvedTypeRefs; 201 202 /// \brief The result type for a landingpad. 203 Type *LandingPadResultTy; 204 205 /// \brief Whether we've seen a call to @llvm.localescape in this function 206 /// already. 207 bool SawFrameEscape; 208 209 /// Stores the count of how many objects were passed to llvm.localescape for a 210 /// given function and the largest index passed to llvm.localrecover. 211 DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo; 212 213 // Maps catchswitches and cleanuppads that unwind to siblings to the 214 // terminators that indicate the unwind, used to detect cycles therein. 215 MapVector<Instruction *, TerminatorInst *> SiblingFuncletInfo; 216 217 /// Cache of constants visited in search of ConstantExprs. 218 SmallPtrSet<const Constant *, 32> ConstantExprVisited; 219 220 void checkAtomicMemAccessSize(const Module *M, Type *Ty, 221 const Instruction *I); 222public: 223 explicit Verifier(raw_ostream &OS) 224 : VerifierSupport(OS), Context(nullptr), LandingPadResultTy(nullptr), 225 SawFrameEscape(false) {} 226 227 bool verify(const Function &F) { 228 M = F.getParent(); 229 Context = &M->getContext(); 230 231 // First ensure the function is well-enough formed to compute dominance 232 // information. 233 if (F.empty()) { 234 OS << "Function '" << F.getName() 235 << "' does not contain an entry block!\n"; 236 return false; 237 } 238 for (Function::const_iterator I = F.begin(), E = F.end(); I != E; ++I) { 239 if (I->empty() || !I->back().isTerminator()) { 240 OS << "Basic Block in function '" << F.getName() 241 << "' does not have terminator!\n"; 242 I->printAsOperand(OS, true); 243 OS << "\n"; 244 return false; 245 } 246 } 247 248 // Now directly compute a dominance tree. We don't rely on the pass 249 // manager to provide this as it isolates us from a potentially 250 // out-of-date dominator tree and makes it significantly more complex to 251 // run this code outside of a pass manager. 252 // FIXME: It's really gross that we have to cast away constness here. 253 DT.recalculate(const_cast<Function &>(F)); 254 255 Broken = false; 256 // FIXME: We strip const here because the inst visitor strips const. 257 visit(const_cast<Function &>(F)); 258 verifySiblingFuncletUnwinds(); 259 InstsInThisBlock.clear(); 260 LandingPadResultTy = nullptr; 261 SawFrameEscape = false; 262 SiblingFuncletInfo.clear(); 263 264 return !Broken; 265 } 266 267 bool verify(const Module &M) { 268 this->M = &M; 269 Context = &M.getContext(); 270 Broken = false; 271 272 // Scan through, checking all of the external function's linkage now... 273 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 274 visitGlobalValue(*I); 275 276 // Check to make sure function prototypes are okay. 277 if (I->isDeclaration()) 278 visitFunction(*I); 279 } 280 281 // Now that we've visited every function, verify that we never asked to 282 // recover a frame index that wasn't escaped. 283 verifyFrameRecoverIndices(); 284 285 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 286 I != E; ++I) 287 visitGlobalVariable(*I); 288 289 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 290 I != E; ++I) 291 visitGlobalAlias(*I); 292 293 for (Module::const_named_metadata_iterator I = M.named_metadata_begin(), 294 E = M.named_metadata_end(); 295 I != E; ++I) 296 visitNamedMDNode(*I); 297 298 for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable()) 299 visitComdat(SMEC.getValue()); 300 301 visitModuleFlags(M); 302 visitModuleIdents(M); 303 304 // Verify type referneces last. 305 verifyTypeRefs(); 306 307 return !Broken; 308 } 309 310private: 311 // Verification methods... 312 void visitGlobalValue(const GlobalValue &GV); 313 void visitGlobalVariable(const GlobalVariable &GV); 314 void visitGlobalAlias(const GlobalAlias &GA); 315 void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C); 316 void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited, 317 const GlobalAlias &A, const Constant &C); 318 void visitNamedMDNode(const NamedMDNode &NMD); 319 void visitMDNode(const MDNode &MD); 320 void visitMetadataAsValue(const MetadataAsValue &MD, Function *F); 321 void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F); 322 void visitComdat(const Comdat &C); 323 void visitModuleIdents(const Module &M); 324 void visitModuleFlags(const Module &M); 325 void visitModuleFlag(const MDNode *Op, 326 DenseMap<const MDString *, const MDNode *> &SeenIDs, 327 SmallVectorImpl<const MDNode *> &Requirements); 328 void visitFunction(const Function &F); 329 void visitBasicBlock(BasicBlock &BB); 330 void visitRangeMetadata(Instruction& I, MDNode* Range, Type* Ty); 331 void visitDereferenceableMetadata(Instruction& I, MDNode* MD); 332 333 template <class Ty> bool isValidMetadataArray(const MDTuple &N); 334#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N); 335#include "llvm/IR/Metadata.def" 336 void visitDIScope(const DIScope &N); 337 void visitDIVariable(const DIVariable &N); 338 void visitDILexicalBlockBase(const DILexicalBlockBase &N); 339 void visitDITemplateParameter(const DITemplateParameter &N); 340 341 void visitTemplateParams(const MDNode &N, const Metadata &RawParams); 342 343 /// \brief Check for a valid string-based type reference. 344 /// 345 /// Checks if \c MD is a string-based type reference. If it is, keeps track 346 /// of it (and its user, \c N) for error messages later. 347 bool isValidUUID(const MDNode &N, const Metadata *MD); 348 349 /// \brief Check for a valid type reference. 350 /// 351 /// Checks for subclasses of \a DIType, or \a isValidUUID(). 352 bool isTypeRef(const MDNode &N, const Metadata *MD); 353 354 /// \brief Check for a valid scope reference. 355 /// 356 /// Checks for subclasses of \a DIScope, or \a isValidUUID(). 357 bool isScopeRef(const MDNode &N, const Metadata *MD); 358 359 /// \brief Check for a valid debug info reference. 360 /// 361 /// Checks for subclasses of \a DINode, or \a isValidUUID(). 362 bool isDIRef(const MDNode &N, const Metadata *MD); 363 364 // InstVisitor overrides... 365 using InstVisitor<Verifier>::visit; 366 void visit(Instruction &I); 367 368 void visitTruncInst(TruncInst &I); 369 void visitZExtInst(ZExtInst &I); 370 void visitSExtInst(SExtInst &I); 371 void visitFPTruncInst(FPTruncInst &I); 372 void visitFPExtInst(FPExtInst &I); 373 void visitFPToUIInst(FPToUIInst &I); 374 void visitFPToSIInst(FPToSIInst &I); 375 void visitUIToFPInst(UIToFPInst &I); 376 void visitSIToFPInst(SIToFPInst &I); 377 void visitIntToPtrInst(IntToPtrInst &I); 378 void visitPtrToIntInst(PtrToIntInst &I); 379 void visitBitCastInst(BitCastInst &I); 380 void visitAddrSpaceCastInst(AddrSpaceCastInst &I); 381 void visitPHINode(PHINode &PN); 382 void visitBinaryOperator(BinaryOperator &B); 383 void visitICmpInst(ICmpInst &IC); 384 void visitFCmpInst(FCmpInst &FC); 385 void visitExtractElementInst(ExtractElementInst &EI); 386 void visitInsertElementInst(InsertElementInst &EI); 387 void visitShuffleVectorInst(ShuffleVectorInst &EI); 388 void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); } 389 void visitCallInst(CallInst &CI); 390 void visitInvokeInst(InvokeInst &II); 391 void visitGetElementPtrInst(GetElementPtrInst &GEP); 392 void visitLoadInst(LoadInst &LI); 393 void visitStoreInst(StoreInst &SI); 394 void verifyDominatesUse(Instruction &I, unsigned i); 395 void visitInstruction(Instruction &I); 396 void visitTerminatorInst(TerminatorInst &I); 397 void visitBranchInst(BranchInst &BI); 398 void visitReturnInst(ReturnInst &RI); 399 void visitSwitchInst(SwitchInst &SI); 400 void visitIndirectBrInst(IndirectBrInst &BI); 401 void visitSelectInst(SelectInst &SI); 402 void visitUserOp1(Instruction &I); 403 void visitUserOp2(Instruction &I) { visitUserOp1(I); } 404 void visitIntrinsicCallSite(Intrinsic::ID ID, CallSite CS); 405 template <class DbgIntrinsicTy> 406 void visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII); 407 void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI); 408 void visitAtomicRMWInst(AtomicRMWInst &RMWI); 409 void visitFenceInst(FenceInst &FI); 410 void visitAllocaInst(AllocaInst &AI); 411 void visitExtractValueInst(ExtractValueInst &EVI); 412 void visitInsertValueInst(InsertValueInst &IVI); 413 void visitEHPadPredecessors(Instruction &I); 414 void visitLandingPadInst(LandingPadInst &LPI); 415 void visitCatchPadInst(CatchPadInst &CPI); 416 void visitCatchReturnInst(CatchReturnInst &CatchReturn); 417 void visitCleanupPadInst(CleanupPadInst &CPI); 418 void visitFuncletPadInst(FuncletPadInst &FPI); 419 void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch); 420 void visitCleanupReturnInst(CleanupReturnInst &CRI); 421 422 void VerifyCallSite(CallSite CS); 423 void verifyMustTailCall(CallInst &CI); 424 bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT, 425 unsigned ArgNo, std::string &Suffix); 426 bool VerifyIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos, 427 SmallVectorImpl<Type *> &ArgTys); 428 bool VerifyIntrinsicIsVarArg(bool isVarArg, 429 ArrayRef<Intrinsic::IITDescriptor> &Infos); 430 bool VerifyAttributeCount(AttributeSet Attrs, unsigned Params); 431 void VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction, 432 const Value *V); 433 void VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 434 bool isReturnValue, const Value *V); 435 void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 436 const Value *V); 437 void VerifyFunctionMetadata( 438 const SmallVector<std::pair<unsigned, MDNode *>, 4> MDs); 439 440 void visitConstantExprsRecursively(const Constant *EntryC); 441 void visitConstantExpr(const ConstantExpr *CE); 442 void VerifyStatepoint(ImmutableCallSite CS); 443 void verifyFrameRecoverIndices(); 444 void verifySiblingFuncletUnwinds(); 445 446 // Module-level debug info verification... 447 void verifyTypeRefs(); 448 template <class MapTy> 449 void verifyBitPieceExpression(const DbgInfoIntrinsic &I, 450 const MapTy &TypeRefs); 451 void visitUnresolvedTypeRef(const MDString *S, const MDNode *N); 452}; 453} // End anonymous namespace 454 455// Assert - We know that cond should be true, if not print an error message. 456#define Assert(C, ...) \ 457 do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (0) 458 459void Verifier::visit(Instruction &I) { 460 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) 461 Assert(I.getOperand(i) != nullptr, "Operand is null", &I); 462 InstVisitor<Verifier>::visit(I); 463} 464 465 466void Verifier::visitGlobalValue(const GlobalValue &GV) { 467 Assert(!GV.isDeclaration() || GV.hasExternalLinkage() || 468 GV.hasExternalWeakLinkage(), 469 "Global is external, but doesn't have external or weak linkage!", &GV); 470 471 Assert(GV.getAlignment() <= Value::MaximumAlignment, 472 "huge alignment values are unsupported", &GV); 473 Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV), 474 "Only global variables can have appending linkage!", &GV); 475 476 if (GV.hasAppendingLinkage()) { 477 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV); 478 Assert(GVar && GVar->getValueType()->isArrayTy(), 479 "Only global arrays can have appending linkage!", GVar); 480 } 481 482 if (GV.isDeclarationForLinker()) 483 Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV); 484} 485 486void Verifier::visitGlobalVariable(const GlobalVariable &GV) { 487 if (GV.hasInitializer()) { 488 Assert(GV.getInitializer()->getType() == GV.getType()->getElementType(), 489 "Global variable initializer type does not match global " 490 "variable type!", 491 &GV); 492 493 // If the global has common linkage, it must have a zero initializer and 494 // cannot be constant. 495 if (GV.hasCommonLinkage()) { 496 Assert(GV.getInitializer()->isNullValue(), 497 "'common' global must have a zero initializer!", &GV); 498 Assert(!GV.isConstant(), "'common' global may not be marked constant!", 499 &GV); 500 Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV); 501 } 502 } else { 503 Assert(GV.hasExternalLinkage() || GV.hasExternalWeakLinkage(), 504 "invalid linkage type for global declaration", &GV); 505 } 506 507 if (GV.hasName() && (GV.getName() == "llvm.global_ctors" || 508 GV.getName() == "llvm.global_dtors")) { 509 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(), 510 "invalid linkage for intrinsic global variable", &GV); 511 // Don't worry about emitting an error for it not being an array, 512 // visitGlobalValue will complain on appending non-array. 513 if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) { 514 StructType *STy = dyn_cast<StructType>(ATy->getElementType()); 515 PointerType *FuncPtrTy = 516 FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo(); 517 // FIXME: Reject the 2-field form in LLVM 4.0. 518 Assert(STy && 519 (STy->getNumElements() == 2 || STy->getNumElements() == 3) && 520 STy->getTypeAtIndex(0u)->isIntegerTy(32) && 521 STy->getTypeAtIndex(1) == FuncPtrTy, 522 "wrong type for intrinsic global variable", &GV); 523 if (STy->getNumElements() == 3) { 524 Type *ETy = STy->getTypeAtIndex(2); 525 Assert(ETy->isPointerTy() && 526 cast<PointerType>(ETy)->getElementType()->isIntegerTy(8), 527 "wrong type for intrinsic global variable", &GV); 528 } 529 } 530 } 531 532 if (GV.hasName() && (GV.getName() == "llvm.used" || 533 GV.getName() == "llvm.compiler.used")) { 534 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(), 535 "invalid linkage for intrinsic global variable", &GV); 536 Type *GVType = GV.getValueType(); 537 if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) { 538 PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType()); 539 Assert(PTy, "wrong type for intrinsic global variable", &GV); 540 if (GV.hasInitializer()) { 541 const Constant *Init = GV.getInitializer(); 542 const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init); 543 Assert(InitArray, "wrong initalizer for intrinsic global variable", 544 Init); 545 for (unsigned i = 0, e = InitArray->getNumOperands(); i != e; ++i) { 546 Value *V = Init->getOperand(i)->stripPointerCastsNoFollowAliases(); 547 Assert(isa<GlobalVariable>(V) || isa<Function>(V) || 548 isa<GlobalAlias>(V), 549 "invalid llvm.used member", V); 550 Assert(V->hasName(), "members of llvm.used must be named", V); 551 } 552 } 553 } 554 } 555 556 Assert(!GV.hasDLLImportStorageClass() || 557 (GV.isDeclaration() && GV.hasExternalLinkage()) || 558 GV.hasAvailableExternallyLinkage(), 559 "Global is marked as dllimport, but not external", &GV); 560 561 if (!GV.hasInitializer()) { 562 visitGlobalValue(GV); 563 return; 564 } 565 566 // Walk any aggregate initializers looking for bitcasts between address spaces 567 visitConstantExprsRecursively(GV.getInitializer()); 568 569 visitGlobalValue(GV); 570} 571 572void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) { 573 SmallPtrSet<const GlobalAlias*, 4> Visited; 574 Visited.insert(&GA); 575 visitAliaseeSubExpr(Visited, GA, C); 576} 577 578void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited, 579 const GlobalAlias &GA, const Constant &C) { 580 if (const auto *GV = dyn_cast<GlobalValue>(&C)) { 581 Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition", 582 &GA); 583 584 if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) { 585 Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA); 586 587 Assert(!GA2->mayBeOverridden(), "Alias cannot point to a weak alias", 588 &GA); 589 } else { 590 // Only continue verifying subexpressions of GlobalAliases. 591 // Do not recurse into global initializers. 592 return; 593 } 594 } 595 596 if (const auto *CE = dyn_cast<ConstantExpr>(&C)) 597 visitConstantExprsRecursively(CE); 598 599 for (const Use &U : C.operands()) { 600 Value *V = &*U; 601 if (const auto *GA2 = dyn_cast<GlobalAlias>(V)) 602 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee()); 603 else if (const auto *C2 = dyn_cast<Constant>(V)) 604 visitAliaseeSubExpr(Visited, GA, *C2); 605 } 606} 607 608void Verifier::visitGlobalAlias(const GlobalAlias &GA) { 609 Assert(GlobalAlias::isValidLinkage(GA.getLinkage()), 610 "Alias should have private, internal, linkonce, weak, linkonce_odr, " 611 "weak_odr, or external linkage!", 612 &GA); 613 const Constant *Aliasee = GA.getAliasee(); 614 Assert(Aliasee, "Aliasee cannot be NULL!", &GA); 615 Assert(GA.getType() == Aliasee->getType(), 616 "Alias and aliasee types should match!", &GA); 617 618 Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee), 619 "Aliasee should be either GlobalValue or ConstantExpr", &GA); 620 621 visitAliaseeSubExpr(GA, *Aliasee); 622 623 visitGlobalValue(GA); 624} 625 626void Verifier::visitNamedMDNode(const NamedMDNode &NMD) { 627 for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) { 628 MDNode *MD = NMD.getOperand(i); 629 630 if (NMD.getName() == "llvm.dbg.cu") { 631 Assert(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD); 632 } 633 634 if (!MD) 635 continue; 636 637 visitMDNode(*MD); 638 } 639} 640 641void Verifier::visitMDNode(const MDNode &MD) { 642 // Only visit each node once. Metadata can be mutually recursive, so this 643 // avoids infinite recursion here, as well as being an optimization. 644 if (!MDNodes.insert(&MD).second) 645 return; 646 647 switch (MD.getMetadataID()) { 648 default: 649 llvm_unreachable("Invalid MDNode subclass"); 650 case Metadata::MDTupleKind: 651 break; 652#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \ 653 case Metadata::CLASS##Kind: \ 654 visit##CLASS(cast<CLASS>(MD)); \ 655 break; 656#include "llvm/IR/Metadata.def" 657 } 658 659 for (unsigned i = 0, e = MD.getNumOperands(); i != e; ++i) { 660 Metadata *Op = MD.getOperand(i); 661 if (!Op) 662 continue; 663 Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!", 664 &MD, Op); 665 if (auto *N = dyn_cast<MDNode>(Op)) { 666 visitMDNode(*N); 667 continue; 668 } 669 if (auto *V = dyn_cast<ValueAsMetadata>(Op)) { 670 visitValueAsMetadata(*V, nullptr); 671 continue; 672 } 673 } 674 675 // Check these last, so we diagnose problems in operands first. 676 Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD); 677 Assert(MD.isResolved(), "All nodes should be resolved!", &MD); 678} 679 680void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) { 681 Assert(MD.getValue(), "Expected valid value", &MD); 682 Assert(!MD.getValue()->getType()->isMetadataTy(), 683 "Unexpected metadata round-trip through values", &MD, MD.getValue()); 684 685 auto *L = dyn_cast<LocalAsMetadata>(&MD); 686 if (!L) 687 return; 688 689 Assert(F, "function-local metadata used outside a function", L); 690 691 // If this was an instruction, bb, or argument, verify that it is in the 692 // function that we expect. 693 Function *ActualF = nullptr; 694 if (Instruction *I = dyn_cast<Instruction>(L->getValue())) { 695 Assert(I->getParent(), "function-local metadata not in basic block", L, I); 696 ActualF = I->getParent()->getParent(); 697 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue())) 698 ActualF = BB->getParent(); 699 else if (Argument *A = dyn_cast<Argument>(L->getValue())) 700 ActualF = A->getParent(); 701 assert(ActualF && "Unimplemented function local metadata case!"); 702 703 Assert(ActualF == F, "function-local metadata used in wrong function", L); 704} 705 706void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) { 707 Metadata *MD = MDV.getMetadata(); 708 if (auto *N = dyn_cast<MDNode>(MD)) { 709 visitMDNode(*N); 710 return; 711 } 712 713 // Only visit each node once. Metadata can be mutually recursive, so this 714 // avoids infinite recursion here, as well as being an optimization. 715 if (!MDNodes.insert(MD).second) 716 return; 717 718 if (auto *V = dyn_cast<ValueAsMetadata>(MD)) 719 visitValueAsMetadata(*V, F); 720} 721 722bool Verifier::isValidUUID(const MDNode &N, const Metadata *MD) { 723 auto *S = dyn_cast<MDString>(MD); 724 if (!S) 725 return false; 726 if (S->getString().empty()) 727 return false; 728 729 // Keep track of names of types referenced via UUID so we can check that they 730 // actually exist. 731 UnresolvedTypeRefs.insert(std::make_pair(S, &N)); 732 return true; 733} 734 735/// \brief Check if a value can be a reference to a type. 736bool Verifier::isTypeRef(const MDNode &N, const Metadata *MD) { 737 return !MD || isValidUUID(N, MD) || isa<DIType>(MD); 738} 739 740/// \brief Check if a value can be a ScopeRef. 741bool Verifier::isScopeRef(const MDNode &N, const Metadata *MD) { 742 return !MD || isValidUUID(N, MD) || isa<DIScope>(MD); 743} 744 745/// \brief Check if a value can be a debug info ref. 746bool Verifier::isDIRef(const MDNode &N, const Metadata *MD) { 747 return !MD || isValidUUID(N, MD) || isa<DINode>(MD); 748} 749 750template <class Ty> 751bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull) { 752 for (Metadata *MD : N.operands()) { 753 if (MD) { 754 if (!isa<Ty>(MD)) 755 return false; 756 } else { 757 if (!AllowNull) 758 return false; 759 } 760 } 761 return true; 762} 763 764template <class Ty> 765bool isValidMetadataArray(const MDTuple &N) { 766 return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ false); 767} 768 769template <class Ty> 770bool isValidMetadataNullArray(const MDTuple &N) { 771 return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ true); 772} 773 774void Verifier::visitDILocation(const DILocation &N) { 775 Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), 776 "location requires a valid scope", &N, N.getRawScope()); 777 if (auto *IA = N.getRawInlinedAt()) 778 Assert(isa<DILocation>(IA), "inlined-at should be a location", &N, IA); 779} 780 781void Verifier::visitGenericDINode(const GenericDINode &N) { 782 Assert(N.getTag(), "invalid tag", &N); 783} 784 785void Verifier::visitDIScope(const DIScope &N) { 786 if (auto *F = N.getRawFile()) 787 Assert(isa<DIFile>(F), "invalid file", &N, F); 788} 789 790void Verifier::visitDISubrange(const DISubrange &N) { 791 Assert(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N); 792 Assert(N.getCount() >= -1, "invalid subrange count", &N); 793} 794 795void Verifier::visitDIEnumerator(const DIEnumerator &N) { 796 Assert(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N); 797} 798 799void Verifier::visitDIBasicType(const DIBasicType &N) { 800 Assert(N.getTag() == dwarf::DW_TAG_base_type || 801 N.getTag() == dwarf::DW_TAG_unspecified_type, 802 "invalid tag", &N); 803} 804 805void Verifier::visitDIDerivedType(const DIDerivedType &N) { 806 // Common scope checks. 807 visitDIScope(N); 808 809 Assert(N.getTag() == dwarf::DW_TAG_typedef || 810 N.getTag() == dwarf::DW_TAG_pointer_type || 811 N.getTag() == dwarf::DW_TAG_ptr_to_member_type || 812 N.getTag() == dwarf::DW_TAG_reference_type || 813 N.getTag() == dwarf::DW_TAG_rvalue_reference_type || 814 N.getTag() == dwarf::DW_TAG_const_type || 815 N.getTag() == dwarf::DW_TAG_volatile_type || 816 N.getTag() == dwarf::DW_TAG_restrict_type || 817 N.getTag() == dwarf::DW_TAG_member || 818 N.getTag() == dwarf::DW_TAG_inheritance || 819 N.getTag() == dwarf::DW_TAG_friend, 820 "invalid tag", &N); 821 if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) { 822 Assert(isTypeRef(N, N.getExtraData()), "invalid pointer to member type", &N, 823 N.getExtraData()); 824 } 825 826 Assert(isScopeRef(N, N.getScope()), "invalid scope", &N, N.getScope()); 827 Assert(isTypeRef(N, N.getBaseType()), "invalid base type", &N, 828 N.getBaseType()); 829} 830 831static bool hasConflictingReferenceFlags(unsigned Flags) { 832 return (Flags & DINode::FlagLValueReference) && 833 (Flags & DINode::FlagRValueReference); 834} 835 836void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) { 837 auto *Params = dyn_cast<MDTuple>(&RawParams); 838 Assert(Params, "invalid template params", &N, &RawParams); 839 for (Metadata *Op : Params->operands()) { 840 Assert(Op && isa<DITemplateParameter>(Op), "invalid template parameter", &N, 841 Params, Op); 842 } 843} 844 845void Verifier::visitDICompositeType(const DICompositeType &N) { 846 // Common scope checks. 847 visitDIScope(N); 848 849 Assert(N.getTag() == dwarf::DW_TAG_array_type || 850 N.getTag() == dwarf::DW_TAG_structure_type || 851 N.getTag() == dwarf::DW_TAG_union_type || 852 N.getTag() == dwarf::DW_TAG_enumeration_type || 853 N.getTag() == dwarf::DW_TAG_class_type, 854 "invalid tag", &N); 855 856 Assert(isScopeRef(N, N.getScope()), "invalid scope", &N, N.getScope()); 857 Assert(isTypeRef(N, N.getBaseType()), "invalid base type", &N, 858 N.getBaseType()); 859 860 Assert(!N.getRawElements() || isa<MDTuple>(N.getRawElements()), 861 "invalid composite elements", &N, N.getRawElements()); 862 Assert(isTypeRef(N, N.getRawVTableHolder()), "invalid vtable holder", &N, 863 N.getRawVTableHolder()); 864 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 865 &N); 866 if (auto *Params = N.getRawTemplateParams()) 867 visitTemplateParams(N, *Params); 868 869 if (N.getTag() == dwarf::DW_TAG_class_type || 870 N.getTag() == dwarf::DW_TAG_union_type) { 871 Assert(N.getFile() && !N.getFile()->getFilename().empty(), 872 "class/union requires a filename", &N, N.getFile()); 873 } 874} 875 876void Verifier::visitDISubroutineType(const DISubroutineType &N) { 877 Assert(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N); 878 if (auto *Types = N.getRawTypeArray()) { 879 Assert(isa<MDTuple>(Types), "invalid composite elements", &N, Types); 880 for (Metadata *Ty : N.getTypeArray()->operands()) { 881 Assert(isTypeRef(N, Ty), "invalid subroutine type ref", &N, Types, Ty); 882 } 883 } 884 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 885 &N); 886} 887 888void Verifier::visitDIFile(const DIFile &N) { 889 Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N); 890} 891 892void Verifier::visitDICompileUnit(const DICompileUnit &N) { 893 Assert(N.isDistinct(), "compile units must be distinct", &N); 894 Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N); 895 896 // Don't bother verifying the compilation directory or producer string 897 // as those could be empty. 898 Assert(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N, 899 N.getRawFile()); 900 Assert(!N.getFile()->getFilename().empty(), "invalid filename", &N, 901 N.getFile()); 902 903 if (auto *Array = N.getRawEnumTypes()) { 904 Assert(isa<MDTuple>(Array), "invalid enum list", &N, Array); 905 for (Metadata *Op : N.getEnumTypes()->operands()) { 906 auto *Enum = dyn_cast_or_null<DICompositeType>(Op); 907 Assert(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type, 908 "invalid enum type", &N, N.getEnumTypes(), Op); 909 } 910 } 911 if (auto *Array = N.getRawRetainedTypes()) { 912 Assert(isa<MDTuple>(Array), "invalid retained type list", &N, Array); 913 for (Metadata *Op : N.getRetainedTypes()->operands()) { 914 Assert(Op && isa<DIType>(Op), "invalid retained type", &N, Op); 915 } 916 } 917 if (auto *Array = N.getRawSubprograms()) { 918 Assert(isa<MDTuple>(Array), "invalid subprogram list", &N, Array); 919 for (Metadata *Op : N.getSubprograms()->operands()) { 920 Assert(Op && isa<DISubprogram>(Op), "invalid subprogram ref", &N, Op); 921 } 922 } 923 if (auto *Array = N.getRawGlobalVariables()) { 924 Assert(isa<MDTuple>(Array), "invalid global variable list", &N, Array); 925 for (Metadata *Op : N.getGlobalVariables()->operands()) { 926 Assert(Op && isa<DIGlobalVariable>(Op), "invalid global variable ref", &N, 927 Op); 928 } 929 } 930 if (auto *Array = N.getRawImportedEntities()) { 931 Assert(isa<MDTuple>(Array), "invalid imported entity list", &N, Array); 932 for (Metadata *Op : N.getImportedEntities()->operands()) { 933 Assert(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref", &N, 934 Op); 935 } 936 } 937 if (auto *Array = N.getRawMacros()) { 938 Assert(isa<MDTuple>(Array), "invalid macro list", &N, Array); 939 for (Metadata *Op : N.getMacros()->operands()) { 940 Assert(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op); 941 } 942 } 943} 944 945void Verifier::visitDISubprogram(const DISubprogram &N) { 946 Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N); 947 Assert(isScopeRef(N, N.getRawScope()), "invalid scope", &N, N.getRawScope()); 948 if (auto *T = N.getRawType()) 949 Assert(isa<DISubroutineType>(T), "invalid subroutine type", &N, T); 950 Assert(isTypeRef(N, N.getRawContainingType()), "invalid containing type", &N, 951 N.getRawContainingType()); 952 if (auto *Params = N.getRawTemplateParams()) 953 visitTemplateParams(N, *Params); 954 if (auto *S = N.getRawDeclaration()) { 955 Assert(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(), 956 "invalid subprogram declaration", &N, S); 957 } 958 if (auto *RawVars = N.getRawVariables()) { 959 auto *Vars = dyn_cast<MDTuple>(RawVars); 960 Assert(Vars, "invalid variable list", &N, RawVars); 961 for (Metadata *Op : Vars->operands()) { 962 Assert(Op && isa<DILocalVariable>(Op), "invalid local variable", &N, Vars, 963 Op); 964 } 965 } 966 Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags", 967 &N); 968 969 if (N.isDefinition()) 970 Assert(N.isDistinct(), "subprogram definitions must be distinct", &N); 971} 972 973void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) { 974 Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N); 975 Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), 976 "invalid local scope", &N, N.getRawScope()); 977} 978 979void Verifier::visitDILexicalBlock(const DILexicalBlock &N) { 980 visitDILexicalBlockBase(N); 981 982 Assert(N.getLine() || !N.getColumn(), 983 "cannot have column info without line info", &N); 984} 985 986void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) { 987 visitDILexicalBlockBase(N); 988} 989 990void Verifier::visitDINamespace(const DINamespace &N) { 991 Assert(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N); 992 if (auto *S = N.getRawScope()) 993 Assert(isa<DIScope>(S), "invalid scope ref", &N, S); 994} 995 996void Verifier::visitDIMacro(const DIMacro &N) { 997 Assert(N.getMacinfoType() == dwarf::DW_MACINFO_define || 998 N.getMacinfoType() == dwarf::DW_MACINFO_undef, 999 "invalid macinfo type", &N); 1000 Assert(!N.getName().empty(), "anonymous macro", &N); 1001 if (!N.getValue().empty()) { 1002 assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix"); 1003 } 1004} 1005 1006void Verifier::visitDIMacroFile(const DIMacroFile &N) { 1007 Assert(N.getMacinfoType() == dwarf::DW_MACINFO_start_file, 1008 "invalid macinfo type", &N); 1009 if (auto *F = N.getRawFile()) 1010 Assert(isa<DIFile>(F), "invalid file", &N, F); 1011 1012 if (auto *Array = N.getRawElements()) { 1013 Assert(isa<MDTuple>(Array), "invalid macro list", &N, Array); 1014 for (Metadata *Op : N.getElements()->operands()) { 1015 Assert(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op); 1016 } 1017 } 1018} 1019 1020void Verifier::visitDIModule(const DIModule &N) { 1021 Assert(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N); 1022 Assert(!N.getName().empty(), "anonymous module", &N); 1023} 1024 1025void Verifier::visitDITemplateParameter(const DITemplateParameter &N) { 1026 Assert(isTypeRef(N, N.getType()), "invalid type ref", &N, N.getType()); 1027} 1028 1029void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) { 1030 visitDITemplateParameter(N); 1031 1032 Assert(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag", 1033 &N); 1034} 1035 1036void Verifier::visitDITemplateValueParameter( 1037 const DITemplateValueParameter &N) { 1038 visitDITemplateParameter(N); 1039 1040 Assert(N.getTag() == dwarf::DW_TAG_template_value_parameter || 1041 N.getTag() == dwarf::DW_TAG_GNU_template_template_param || 1042 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack, 1043 "invalid tag", &N); 1044} 1045 1046void Verifier::visitDIVariable(const DIVariable &N) { 1047 if (auto *S = N.getRawScope()) 1048 Assert(isa<DIScope>(S), "invalid scope", &N, S); 1049 Assert(isTypeRef(N, N.getRawType()), "invalid type ref", &N, N.getRawType()); 1050 if (auto *F = N.getRawFile()) 1051 Assert(isa<DIFile>(F), "invalid file", &N, F); 1052} 1053 1054void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) { 1055 // Checks common to all variables. 1056 visitDIVariable(N); 1057 1058 Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N); 1059 Assert(!N.getName().empty(), "missing global variable name", &N); 1060 if (auto *V = N.getRawVariable()) { 1061 Assert(isa<ConstantAsMetadata>(V) && 1062 !isa<Function>(cast<ConstantAsMetadata>(V)->getValue()), 1063 "invalid global varaible ref", &N, V); 1064 } 1065 if (auto *Member = N.getRawStaticDataMemberDeclaration()) { 1066 Assert(isa<DIDerivedType>(Member), "invalid static data member declaration", 1067 &N, Member); 1068 } 1069} 1070 1071void Verifier::visitDILocalVariable(const DILocalVariable &N) { 1072 // Checks common to all variables. 1073 visitDIVariable(N); 1074 1075 Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N); 1076 Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), 1077 "local variable requires a valid scope", &N, N.getRawScope()); 1078} 1079 1080void Verifier::visitDIExpression(const DIExpression &N) { 1081 Assert(N.isValid(), "invalid expression", &N); 1082} 1083 1084void Verifier::visitDIObjCProperty(const DIObjCProperty &N) { 1085 Assert(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N); 1086 if (auto *T = N.getRawType()) 1087 Assert(isTypeRef(N, T), "invalid type ref", &N, T); 1088 if (auto *F = N.getRawFile()) 1089 Assert(isa<DIFile>(F), "invalid file", &N, F); 1090} 1091 1092void Verifier::visitDIImportedEntity(const DIImportedEntity &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<DIScope>(S), "invalid scope for imported entity", &N, S); 1098 Assert(isDIRef(N, N.getEntity()), "invalid imported entity", &N, 1099 N.getEntity()); 1100} 1101 1102void 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 1110void 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 1128void 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 1161void 1162Verifier::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 1228void 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::SafeStack || 1253 I->getKindAsEnum() == Attribute::NoRedZone || 1254 I->getKindAsEnum() == Attribute::NoImplicitFloat || 1255 I->getKindAsEnum() == Attribute::Naked || 1256 I->getKindAsEnum() == Attribute::InlineHint || 1257 I->getKindAsEnum() == Attribute::StackAlignment || 1258 I->getKindAsEnum() == Attribute::UWTable || 1259 I->getKindAsEnum() == Attribute::NonLazyBind || 1260 I->getKindAsEnum() == Attribute::ReturnsTwice || 1261 I->getKindAsEnum() == Attribute::SanitizeAddress || 1262 I->getKindAsEnum() == Attribute::SanitizeThread || 1263 I->getKindAsEnum() == Attribute::SanitizeMemory || 1264 I->getKindAsEnum() == Attribute::MinSize || 1265 I->getKindAsEnum() == Attribute::NoDuplicate || 1266 I->getKindAsEnum() == Attribute::Builtin || 1267 I->getKindAsEnum() == Attribute::NoBuiltin || 1268 I->getKindAsEnum() == Attribute::Cold || 1269 I->getKindAsEnum() == Attribute::OptimizeNone || 1270 I->getKindAsEnum() == Attribute::JumpTable || 1271 I->getKindAsEnum() == Attribute::Convergent || 1272 I->getKindAsEnum() == Attribute::ArgMemOnly || 1273 I->getKindAsEnum() == Attribute::NoRecurse || 1274 I->getKindAsEnum() == Attribute::InaccessibleMemOnly || 1275 I->getKindAsEnum() == Attribute::InaccessibleMemOrArgMemOnly) { 1276 if (!isFunction) { 1277 CheckFailed("Attribute '" + I->getAsString() + 1278 "' only applies to functions!", V); 1279 return; 1280 } 1281 } else if (I->getKindAsEnum() == Attribute::ReadOnly || 1282 I->getKindAsEnum() == Attribute::ReadNone) { 1283 if (Idx == 0) { 1284 CheckFailed("Attribute '" + I->getAsString() + 1285 "' does not apply to function returns"); 1286 return; 1287 } 1288 } else if (isFunction) { 1289 CheckFailed("Attribute '" + I->getAsString() + 1290 "' does not apply to functions!", V); 1291 return; 1292 } 1293 } 1294} 1295 1296// VerifyParameterAttrs - Check the given attributes for an argument or return 1297// value of the specified type. The value V is printed in error messages. 1298void Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 1299 bool isReturnValue, const Value *V) { 1300 if (!Attrs.hasAttributes(Idx)) 1301 return; 1302 1303 VerifyAttributeTypes(Attrs, Idx, false, V); 1304 1305 if (isReturnValue) 1306 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && 1307 !Attrs.hasAttribute(Idx, Attribute::Nest) && 1308 !Attrs.hasAttribute(Idx, Attribute::StructRet) && 1309 !Attrs.hasAttribute(Idx, Attribute::NoCapture) && 1310 !Attrs.hasAttribute(Idx, Attribute::Returned) && 1311 !Attrs.hasAttribute(Idx, Attribute::InAlloca), 1312 "Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', and " 1313 "'returned' do not apply to return values!", 1314 V); 1315 1316 // Check for mutually incompatible attributes. Only inreg is compatible with 1317 // sret. 1318 unsigned AttrCount = 0; 1319 AttrCount += Attrs.hasAttribute(Idx, Attribute::ByVal); 1320 AttrCount += Attrs.hasAttribute(Idx, Attribute::InAlloca); 1321 AttrCount += Attrs.hasAttribute(Idx, Attribute::StructRet) || 1322 Attrs.hasAttribute(Idx, Attribute::InReg); 1323 AttrCount += Attrs.hasAttribute(Idx, Attribute::Nest); 1324 Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', " 1325 "and 'sret' are incompatible!", 1326 V); 1327 1328 Assert(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) && 1329 Attrs.hasAttribute(Idx, Attribute::ReadOnly)), 1330 "Attributes " 1331 "'inalloca and readonly' are incompatible!", 1332 V); 1333 1334 Assert(!(Attrs.hasAttribute(Idx, Attribute::StructRet) && 1335 Attrs.hasAttribute(Idx, Attribute::Returned)), 1336 "Attributes " 1337 "'sret and returned' are incompatible!", 1338 V); 1339 1340 Assert(!(Attrs.hasAttribute(Idx, Attribute::ZExt) && 1341 Attrs.hasAttribute(Idx, Attribute::SExt)), 1342 "Attributes " 1343 "'zeroext and signext' are incompatible!", 1344 V); 1345 1346 Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) && 1347 Attrs.hasAttribute(Idx, Attribute::ReadOnly)), 1348 "Attributes " 1349 "'readnone and readonly' are incompatible!", 1350 V); 1351 1352 Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) && 1353 Attrs.hasAttribute(Idx, Attribute::AlwaysInline)), 1354 "Attributes " 1355 "'noinline and alwaysinline' are incompatible!", 1356 V); 1357 1358 Assert(!AttrBuilder(Attrs, Idx) 1359 .overlaps(AttributeFuncs::typeIncompatible(Ty)), 1360 "Wrong types for attribute: " + 1361 AttributeSet::get(*Context, Idx, 1362 AttributeFuncs::typeIncompatible(Ty)).getAsString(Idx), 1363 V); 1364 1365 if (PointerType *PTy = dyn_cast<PointerType>(Ty)) { 1366 SmallPtrSet<Type*, 4> Visited; 1367 if (!PTy->getElementType()->isSized(&Visited)) { 1368 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && 1369 !Attrs.hasAttribute(Idx, Attribute::InAlloca), 1370 "Attributes 'byval' and 'inalloca' do not support unsized types!", 1371 V); 1372 } 1373 } else { 1374 Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal), 1375 "Attribute 'byval' only applies to parameters with pointer type!", 1376 V); 1377 } 1378} 1379 1380// VerifyFunctionAttrs - Check parameter attributes against a function type. 1381// The value V is printed in error messages. 1382void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 1383 const Value *V) { 1384 if (Attrs.isEmpty()) 1385 return; 1386 1387 bool SawNest = false; 1388 bool SawReturned = false; 1389 bool SawSRet = false; 1390 1391 for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { 1392 unsigned Idx = Attrs.getSlotIndex(i); 1393 1394 Type *Ty; 1395 if (Idx == 0) 1396 Ty = FT->getReturnType(); 1397 else if (Idx-1 < FT->getNumParams()) 1398 Ty = FT->getParamType(Idx-1); 1399 else 1400 break; // VarArgs attributes, verified elsewhere. 1401 1402 VerifyParameterAttrs(Attrs, Idx, Ty, Idx == 0, V); 1403 1404 if (Idx == 0) 1405 continue; 1406 1407 if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 1408 Assert(!SawNest, "More than one parameter has attribute nest!", V); 1409 SawNest = true; 1410 } 1411 1412 if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 1413 Assert(!SawReturned, "More than one parameter has attribute returned!", 1414 V); 1415 Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()), 1416 "Incompatible " 1417 "argument and return types for 'returned' attribute", 1418 V); 1419 SawReturned = true; 1420 } 1421 1422 if (Attrs.hasAttribute(Idx, Attribute::StructRet)) { 1423 Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V); 1424 Assert(Idx == 1 || Idx == 2, 1425 "Attribute 'sret' is not on first or second parameter!", V); 1426 SawSRet = true; 1427 } 1428 1429 if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) { 1430 Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!", 1431 V); 1432 } 1433 } 1434 1435 if (!Attrs.hasAttributes(AttributeSet::FunctionIndex)) 1436 return; 1437 1438 VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V); 1439 1440 Assert( 1441 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && 1442 Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)), 1443 "Attributes 'readnone and readonly' are incompatible!", V); 1444 1445 Assert( 1446 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && 1447 Attrs.hasAttribute(AttributeSet::FunctionIndex, 1448 Attribute::InaccessibleMemOrArgMemOnly)), 1449 "Attributes 'readnone and inaccessiblemem_or_argmemonly' are incompatible!", V); 1450 1451 Assert( 1452 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && 1453 Attrs.hasAttribute(AttributeSet::FunctionIndex, 1454 Attribute::InaccessibleMemOnly)), 1455 "Attributes 'readnone and inaccessiblememonly' are incompatible!", V); 1456 1457 Assert( 1458 !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) && 1459 Attrs.hasAttribute(AttributeSet::FunctionIndex, 1460 Attribute::AlwaysInline)), 1461 "Attributes 'noinline and alwaysinline' are incompatible!", V); 1462 1463 if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 1464 Attribute::OptimizeNone)) { 1465 Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline), 1466 "Attribute 'optnone' requires 'noinline'!", V); 1467 1468 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, 1469 Attribute::OptimizeForSize), 1470 "Attributes 'optsize and optnone' are incompatible!", V); 1471 1472 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize), 1473 "Attributes 'minsize and optnone' are incompatible!", V); 1474 } 1475 1476 if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 1477 Attribute::JumpTable)) { 1478 const GlobalValue *GV = cast<GlobalValue>(V); 1479 Assert(GV->hasUnnamedAddr(), 1480 "Attribute 'jumptable' requires 'unnamed_addr'", V); 1481 } 1482} 1483 1484void Verifier::VerifyFunctionMetadata( 1485 const SmallVector<std::pair<unsigned, MDNode *>, 4> MDs) { 1486 if (MDs.empty()) 1487 return; 1488 1489 for (unsigned i = 0; i < MDs.size(); i++) { 1490 if (MDs[i].first == LLVMContext::MD_prof) { 1491 MDNode *MD = MDs[i].second; 1492 Assert(MD->getNumOperands() == 2, 1493 "!prof annotations should have exactly 2 operands", MD); 1494 1495 // Check first operand. 1496 Assert(MD->getOperand(0) != nullptr, "first operand should not be null", 1497 MD); 1498 Assert(isa<MDString>(MD->getOperand(0)), 1499 "expected string with name of the !prof annotation", MD); 1500 MDString *MDS = cast<MDString>(MD->getOperand(0)); 1501 StringRef ProfName = MDS->getString(); 1502 Assert(ProfName.equals("function_entry_count"), 1503 "first operand should be 'function_entry_count'", MD); 1504 1505 // Check second operand. 1506 Assert(MD->getOperand(1) != nullptr, "second operand should not be null", 1507 MD); 1508 Assert(isa<ConstantAsMetadata>(MD->getOperand(1)), 1509 "expected integer argument to function_entry_count", MD); 1510 } 1511 } 1512} 1513 1514void Verifier::visitConstantExprsRecursively(const Constant *EntryC) { 1515 if (!ConstantExprVisited.insert(EntryC).second) 1516 return; 1517 1518 SmallVector<const Constant *, 16> Stack; 1519 Stack.push_back(EntryC); 1520 1521 while (!Stack.empty()) { 1522 const Constant *C = Stack.pop_back_val(); 1523 1524 // Check this constant expression. 1525 if (const auto *CE = dyn_cast<ConstantExpr>(C)) 1526 visitConstantExpr(CE); 1527 1528 // Visit all sub-expressions. 1529 for (const Use &U : C->operands()) { 1530 const auto *OpC = dyn_cast<Constant>(U); 1531 if (!OpC) 1532 continue; 1533 if (isa<GlobalValue>(OpC)) 1534 continue; // Global values get visited separately. 1535 if (!ConstantExprVisited.insert(OpC).second) 1536 continue; 1537 Stack.push_back(OpC); 1538 } 1539 } 1540} 1541 1542void Verifier::visitConstantExpr(const ConstantExpr *CE) { 1543 if (CE->getOpcode() != Instruction::BitCast) 1544 return; 1545 1546 Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0), 1547 CE->getType()), 1548 "Invalid bitcast", CE); 1549} 1550 1551bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) { 1552 if (Attrs.getNumSlots() == 0) 1553 return true; 1554 1555 unsigned LastSlot = Attrs.getNumSlots() - 1; 1556 unsigned LastIndex = Attrs.getSlotIndex(LastSlot); 1557 if (LastIndex <= Params 1558 || (LastIndex == AttributeSet::FunctionIndex 1559 && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params))) 1560 return true; 1561 1562 return false; 1563} 1564 1565/// \brief Verify that statepoint intrinsic is well formed. 1566void Verifier::VerifyStatepoint(ImmutableCallSite CS) { 1567 assert(CS.getCalledFunction() && 1568 CS.getCalledFunction()->getIntrinsicID() == 1569 Intrinsic::experimental_gc_statepoint); 1570 1571 const Instruction &CI = *CS.getInstruction(); 1572 1573 Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory() && 1574 !CS.onlyAccessesArgMemory(), 1575 "gc.statepoint must read and write all memory to preserve " 1576 "reordering restrictions required by safepoint semantics", 1577 &CI); 1578 1579 const Value *IDV = CS.getArgument(0); 1580 Assert(isa<ConstantInt>(IDV), "gc.statepoint ID must be a constant integer", 1581 &CI); 1582 1583 const Value *NumPatchBytesV = CS.getArgument(1); 1584 Assert(isa<ConstantInt>(NumPatchBytesV), 1585 "gc.statepoint number of patchable bytes must be a constant integer", 1586 &CI); 1587 const int64_t NumPatchBytes = 1588 cast<ConstantInt>(NumPatchBytesV)->getSExtValue(); 1589 assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!"); 1590 Assert(NumPatchBytes >= 0, "gc.statepoint number of patchable bytes must be " 1591 "positive", 1592 &CI); 1593 1594 const Value *Target = CS.getArgument(2); 1595 auto *PT = dyn_cast<PointerType>(Target->getType()); 1596 Assert(PT && PT->getElementType()->isFunctionTy(), 1597 "gc.statepoint callee must be of function pointer type", &CI, Target); 1598 FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType()); 1599 1600 const Value *NumCallArgsV = CS.getArgument(3); 1601 Assert(isa<ConstantInt>(NumCallArgsV), 1602 "gc.statepoint number of arguments to underlying call " 1603 "must be constant integer", 1604 &CI); 1605 const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue(); 1606 Assert(NumCallArgs >= 0, 1607 "gc.statepoint number of arguments to underlying call " 1608 "must be positive", 1609 &CI); 1610 const int NumParams = (int)TargetFuncType->getNumParams(); 1611 if (TargetFuncType->isVarArg()) { 1612 Assert(NumCallArgs >= NumParams, 1613 "gc.statepoint mismatch in number of vararg call args", &CI); 1614 1615 // TODO: Remove this limitation 1616 Assert(TargetFuncType->getReturnType()->isVoidTy(), 1617 "gc.statepoint doesn't support wrapping non-void " 1618 "vararg functions yet", 1619 &CI); 1620 } else 1621 Assert(NumCallArgs == NumParams, 1622 "gc.statepoint mismatch in number of call args", &CI); 1623 1624 const Value *FlagsV = CS.getArgument(4); 1625 Assert(isa<ConstantInt>(FlagsV), 1626 "gc.statepoint flags must be constant integer", &CI); 1627 const uint64_t Flags = cast<ConstantInt>(FlagsV)->getZExtValue(); 1628 Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0, 1629 "unknown flag used in gc.statepoint flags argument", &CI); 1630 1631 // Verify that the types of the call parameter arguments match 1632 // the type of the wrapped callee. 1633 for (int i = 0; i < NumParams; i++) { 1634 Type *ParamType = TargetFuncType->getParamType(i); 1635 Type *ArgType = CS.getArgument(5 + i)->getType(); 1636 Assert(ArgType == ParamType, 1637 "gc.statepoint call argument does not match wrapped " 1638 "function type", 1639 &CI); 1640 } 1641 1642 const int EndCallArgsInx = 4 + NumCallArgs; 1643 1644 const Value *NumTransitionArgsV = CS.getArgument(EndCallArgsInx+1); 1645 Assert(isa<ConstantInt>(NumTransitionArgsV), 1646 "gc.statepoint number of transition arguments " 1647 "must be constant integer", 1648 &CI); 1649 const int NumTransitionArgs = 1650 cast<ConstantInt>(NumTransitionArgsV)->getZExtValue(); 1651 Assert(NumTransitionArgs >= 0, 1652 "gc.statepoint number of transition arguments must be positive", &CI); 1653 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs; 1654 1655 const Value *NumDeoptArgsV = CS.getArgument(EndTransitionArgsInx+1); 1656 Assert(isa<ConstantInt>(NumDeoptArgsV), 1657 "gc.statepoint number of deoptimization arguments " 1658 "must be constant integer", 1659 &CI); 1660 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue(); 1661 Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments " 1662 "must be positive", 1663 &CI); 1664 1665 const int ExpectedNumArgs = 1666 7 + NumCallArgs + NumTransitionArgs + NumDeoptArgs; 1667 Assert(ExpectedNumArgs <= (int)CS.arg_size(), 1668 "gc.statepoint too few arguments according to length fields", &CI); 1669 1670 // Check that the only uses of this gc.statepoint are gc.result or 1671 // gc.relocate calls which are tied to this statepoint and thus part 1672 // of the same statepoint sequence 1673 for (const User *U : CI.users()) { 1674 const CallInst *Call = dyn_cast<const CallInst>(U); 1675 Assert(Call, "illegal use of statepoint token", &CI, U); 1676 if (!Call) continue; 1677 Assert(isa<GCRelocateInst>(Call) || isGCResult(Call), 1678 "gc.result or gc.relocate are the only value uses" 1679 "of a gc.statepoint", 1680 &CI, U); 1681 if (isGCResult(Call)) { 1682 Assert(Call->getArgOperand(0) == &CI, 1683 "gc.result connected to wrong gc.statepoint", &CI, Call); 1684 } else if (isa<GCRelocateInst>(Call)) { 1685 Assert(Call->getArgOperand(0) == &CI, 1686 "gc.relocate connected to wrong gc.statepoint", &CI, Call); 1687 } 1688 } 1689 1690 // Note: It is legal for a single derived pointer to be listed multiple 1691 // times. It's non-optimal, but it is legal. It can also happen after 1692 // insertion if we strip a bitcast away. 1693 // Note: It is really tempting to check that each base is relocated and 1694 // that a derived pointer is never reused as a base pointer. This turns 1695 // out to be problematic since optimizations run after safepoint insertion 1696 // can recognize equality properties that the insertion logic doesn't know 1697 // about. See example statepoint.ll in the verifier subdirectory 1698} 1699 1700void Verifier::verifyFrameRecoverIndices() { 1701 for (auto &Counts : FrameEscapeInfo) { 1702 Function *F = Counts.first; 1703 unsigned EscapedObjectCount = Counts.second.first; 1704 unsigned MaxRecoveredIndex = Counts.second.second; 1705 Assert(MaxRecoveredIndex <= EscapedObjectCount, 1706 "all indices passed to llvm.localrecover must be less than the " 1707 "number of arguments passed ot llvm.localescape in the parent " 1708 "function", 1709 F); 1710 } 1711} 1712 1713static Instruction *getSuccPad(TerminatorInst *Terminator) { 1714 BasicBlock *UnwindDest; 1715 if (auto *II = dyn_cast<InvokeInst>(Terminator)) 1716 UnwindDest = II->getUnwindDest(); 1717 else if (auto *CSI = dyn_cast<CatchSwitchInst>(Terminator)) 1718 UnwindDest = CSI->getUnwindDest(); 1719 else 1720 UnwindDest = cast<CleanupReturnInst>(Terminator)->getUnwindDest(); 1721 return UnwindDest->getFirstNonPHI(); 1722} 1723 1724void Verifier::verifySiblingFuncletUnwinds() { 1725 SmallPtrSet<Instruction *, 8> Visited; 1726 SmallPtrSet<Instruction *, 8> Active; 1727 for (const auto &Pair : SiblingFuncletInfo) { 1728 Instruction *PredPad = Pair.first; 1729 if (Visited.count(PredPad)) 1730 continue; 1731 Active.insert(PredPad); 1732 TerminatorInst *Terminator = Pair.second; 1733 do { 1734 Instruction *SuccPad = getSuccPad(Terminator); 1735 if (Active.count(SuccPad)) { 1736 // Found a cycle; report error 1737 Instruction *CyclePad = SuccPad; 1738 SmallVector<Instruction *, 8> CycleNodes; 1739 do { 1740 CycleNodes.push_back(CyclePad); 1741 TerminatorInst *CycleTerminator = SiblingFuncletInfo[CyclePad]; 1742 if (CycleTerminator != CyclePad) 1743 CycleNodes.push_back(CycleTerminator); 1744 CyclePad = getSuccPad(CycleTerminator); 1745 } while (CyclePad != SuccPad); 1746 Assert(false, "EH pads can't handle each other's exceptions", 1747 ArrayRef<Instruction *>(CycleNodes)); 1748 } 1749 // Don't re-walk a node we've already checked 1750 if (!Visited.insert(SuccPad).second) 1751 break; 1752 // Walk to this successor if it has a map entry. 1753 PredPad = SuccPad; 1754 auto TermI = SiblingFuncletInfo.find(PredPad); 1755 if (TermI == SiblingFuncletInfo.end()) 1756 break; 1757 Terminator = TermI->second; 1758 Active.insert(PredPad); 1759 } while (true); 1760 // Each node only has one successor, so we've walked all the active 1761 // nodes' successors. 1762 Active.clear(); 1763 } 1764} 1765 1766// visitFunction - Verify that a function is ok. 1767// 1768void Verifier::visitFunction(const Function &F) { 1769 // Check function arguments. 1770 FunctionType *FT = F.getFunctionType(); 1771 unsigned NumArgs = F.arg_size(); 1772 1773 Assert(Context == &F.getContext(), 1774 "Function context does not match Module context!", &F); 1775 1776 Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F); 1777 Assert(FT->getNumParams() == NumArgs, 1778 "# formal arguments must match # of arguments for function type!", &F, 1779 FT); 1780 Assert(F.getReturnType()->isFirstClassType() || 1781 F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(), 1782 "Functions cannot return aggregate values!", &F); 1783 1784 Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(), 1785 "Invalid struct return type!", &F); 1786 1787 AttributeSet Attrs = F.getAttributes(); 1788 1789 Assert(VerifyAttributeCount(Attrs, FT->getNumParams()), 1790 "Attribute after last parameter!", &F); 1791 1792 // Check function attributes. 1793 VerifyFunctionAttrs(FT, Attrs, &F); 1794 1795 // On function declarations/definitions, we do not support the builtin 1796 // attribute. We do not check this in VerifyFunctionAttrs since that is 1797 // checking for Attributes that can/can not ever be on functions. 1798 Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin), 1799 "Attribute 'builtin' can only be applied to a callsite.", &F); 1800 1801 // Check that this function meets the restrictions on this calling convention. 1802 // Sometimes varargs is used for perfectly forwarding thunks, so some of these 1803 // restrictions can be lifted. 1804 switch (F.getCallingConv()) { 1805 default: 1806 case CallingConv::C: 1807 break; 1808 case CallingConv::Fast: 1809 case CallingConv::Cold: 1810 case CallingConv::Intel_OCL_BI: 1811 case CallingConv::PTX_Kernel: 1812 case CallingConv::PTX_Device: 1813 Assert(!F.isVarArg(), "Calling convention does not support varargs or " 1814 "perfect forwarding!", 1815 &F); 1816 break; 1817 } 1818 1819 bool isLLVMdotName = F.getName().size() >= 5 && 1820 F.getName().substr(0, 5) == "llvm."; 1821 1822 // Check that the argument values match the function type for this function... 1823 unsigned i = 0; 1824 for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; 1825 ++I, ++i) { 1826 Assert(I->getType() == FT->getParamType(i), 1827 "Argument value does not match function argument type!", I, 1828 FT->getParamType(i)); 1829 Assert(I->getType()->isFirstClassType(), 1830 "Function arguments must have first-class types!", I); 1831 if (!isLLVMdotName) { 1832 Assert(!I->getType()->isMetadataTy(), 1833 "Function takes metadata but isn't an intrinsic", I, &F); 1834 Assert(!I->getType()->isTokenTy(), 1835 "Function takes token but isn't an intrinsic", I, &F); 1836 } 1837 } 1838 1839 if (!isLLVMdotName) 1840 Assert(!F.getReturnType()->isTokenTy(), 1841 "Functions returns a token but isn't an intrinsic", &F); 1842 1843 // Get the function metadata attachments. 1844 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; 1845 F.getAllMetadata(MDs); 1846 assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync"); 1847 VerifyFunctionMetadata(MDs); 1848 1849 // Check validity of the personality function 1850 if (F.hasPersonalityFn()) { 1851 auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()); 1852 if (Per) 1853 Assert(Per->getParent() == F.getParent(), 1854 "Referencing personality function in another module!", 1855 &F, F.getParent(), Per, Per->getParent()); 1856 } 1857 1858 if (F.isMaterializable()) { 1859 // Function has a body somewhere we can't see. 1860 Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F, 1861 MDs.empty() ? nullptr : MDs.front().second); 1862 } else if (F.isDeclaration()) { 1863 Assert(F.hasExternalLinkage() || F.hasExternalWeakLinkage(), 1864 "invalid linkage type for function declaration", &F); 1865 Assert(MDs.empty(), "function without a body cannot have metadata", &F, 1866 MDs.empty() ? nullptr : MDs.front().second); 1867 Assert(!F.hasPersonalityFn(), 1868 "Function declaration shouldn't have a personality routine", &F); 1869 } else { 1870 // Verify that this function (which has a body) is not named "llvm.*". It 1871 // is not legal to define intrinsics. 1872 Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F); 1873 1874 // Check the entry node 1875 const BasicBlock *Entry = &F.getEntryBlock(); 1876 Assert(pred_empty(Entry), 1877 "Entry block to function must not have predecessors!", Entry); 1878 1879 // The address of the entry block cannot be taken, unless it is dead. 1880 if (Entry->hasAddressTaken()) { 1881 Assert(!BlockAddress::lookup(Entry)->isConstantUsed(), 1882 "blockaddress may not be used with the entry block!", Entry); 1883 } 1884 1885 // Visit metadata attachments. 1886 for (const auto &I : MDs) { 1887 // Verify that the attachment is legal. 1888 switch (I.first) { 1889 default: 1890 break; 1891 case LLVMContext::MD_dbg: 1892 Assert(isa<DISubprogram>(I.second), 1893 "function !dbg attachment must be a subprogram", &F, I.second); 1894 break; 1895 } 1896 1897 // Verify the metadata itself. 1898 visitMDNode(*I.second); 1899 } 1900 } 1901 1902 // If this function is actually an intrinsic, verify that it is only used in 1903 // direct call/invokes, never having its "address taken". 1904 // Only do this if the module is materialized, otherwise we don't have all the 1905 // uses. 1906 if (F.getIntrinsicID() && F.getParent()->isMaterialized()) { 1907 const User *U; 1908 if (F.hasAddressTaken(&U)) 1909 Assert(0, "Invalid user of intrinsic instruction!", U); 1910 } 1911 1912 Assert(!F.hasDLLImportStorageClass() || 1913 (F.isDeclaration() && F.hasExternalLinkage()) || 1914 F.hasAvailableExternallyLinkage(), 1915 "Function is marked as dllimport, but not external.", &F); 1916 1917 auto *N = F.getSubprogram(); 1918 if (!N) 1919 return; 1920 1921 // Check that all !dbg attachments lead to back to N (or, at least, another 1922 // subprogram that describes the same function). 1923 // 1924 // FIXME: Check this incrementally while visiting !dbg attachments. 1925 // FIXME: Only check when N is the canonical subprogram for F. 1926 SmallPtrSet<const MDNode *, 32> Seen; 1927 for (auto &BB : F) 1928 for (auto &I : BB) { 1929 // Be careful about using DILocation here since we might be dealing with 1930 // broken code (this is the Verifier after all). 1931 DILocation *DL = 1932 dyn_cast_or_null<DILocation>(I.getDebugLoc().getAsMDNode()); 1933 if (!DL) 1934 continue; 1935 if (!Seen.insert(DL).second) 1936 continue; 1937 1938 DILocalScope *Scope = DL->getInlinedAtScope(); 1939 if (Scope && !Seen.insert(Scope).second) 1940 continue; 1941 1942 DISubprogram *SP = Scope ? Scope->getSubprogram() : nullptr; 1943 1944 // Scope and SP could be the same MDNode and we don't want to skip 1945 // validation in that case 1946 if (SP && ((Scope != SP) && !Seen.insert(SP).second)) 1947 continue; 1948 1949 // FIXME: Once N is canonical, check "SP == &N". 1950 Assert(SP->describes(&F), 1951 "!dbg attachment points at wrong subprogram for function", N, &F, 1952 &I, DL, Scope, SP); 1953 } 1954} 1955 1956// verifyBasicBlock - Verify that a basic block is well formed... 1957// 1958void Verifier::visitBasicBlock(BasicBlock &BB) { 1959 InstsInThisBlock.clear(); 1960 1961 // Ensure that basic blocks have terminators! 1962 Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB); 1963 1964 // Check constraints that this basic block imposes on all of the PHI nodes in 1965 // it. 1966 if (isa<PHINode>(BB.front())) { 1967 SmallVector<BasicBlock*, 8> Preds(pred_begin(&BB), pred_end(&BB)); 1968 SmallVector<std::pair<BasicBlock*, Value*>, 8> Values; 1969 std::sort(Preds.begin(), Preds.end()); 1970 PHINode *PN; 1971 for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) { 1972 // Ensure that PHI nodes have at least one entry! 1973 Assert(PN->getNumIncomingValues() != 0, 1974 "PHI nodes must have at least one entry. If the block is dead, " 1975 "the PHI should be removed!", 1976 PN); 1977 Assert(PN->getNumIncomingValues() == Preds.size(), 1978 "PHINode should have one entry for each predecessor of its " 1979 "parent basic block!", 1980 PN); 1981 1982 // Get and sort all incoming values in the PHI node... 1983 Values.clear(); 1984 Values.reserve(PN->getNumIncomingValues()); 1985 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 1986 Values.push_back(std::make_pair(PN->getIncomingBlock(i), 1987 PN->getIncomingValue(i))); 1988 std::sort(Values.begin(), Values.end()); 1989 1990 for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1991 // Check to make sure that if there is more than one entry for a 1992 // particular basic block in this PHI node, that the incoming values are 1993 // all identical. 1994 // 1995 Assert(i == 0 || Values[i].first != Values[i - 1].first || 1996 Values[i].second == Values[i - 1].second, 1997 "PHI node has multiple entries for the same basic block with " 1998 "different incoming values!", 1999 PN, Values[i].first, Values[i].second, Values[i - 1].second); 2000 2001 // Check to make sure that the predecessors and PHI node entries are 2002 // matched up. 2003 Assert(Values[i].first == Preds[i], 2004 "PHI node entries do not match predecessors!", PN, 2005 Values[i].first, Preds[i]); 2006 } 2007 } 2008 } 2009 2010 // Check that all instructions have their parent pointers set up correctly. 2011 for (auto &I : BB) 2012 { 2013 Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!"); 2014 } 2015} 2016 2017void Verifier::visitTerminatorInst(TerminatorInst &I) { 2018 // Ensure that terminators only exist at the end of the basic block. 2019 Assert(&I == I.getParent()->getTerminator(), 2020 "Terminator found in the middle of a basic block!", I.getParent()); 2021 visitInstruction(I); 2022} 2023 2024void Verifier::visitBranchInst(BranchInst &BI) { 2025 if (BI.isConditional()) { 2026 Assert(BI.getCondition()->getType()->isIntegerTy(1), 2027 "Branch condition is not 'i1' type!", &BI, BI.getCondition()); 2028 } 2029 visitTerminatorInst(BI); 2030} 2031 2032void Verifier::visitReturnInst(ReturnInst &RI) { 2033 Function *F = RI.getParent()->getParent(); 2034 unsigned N = RI.getNumOperands(); 2035 if (F->getReturnType()->isVoidTy()) 2036 Assert(N == 0, 2037 "Found return instr that returns non-void in Function of void " 2038 "return type!", 2039 &RI, F->getReturnType()); 2040 else 2041 Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(), 2042 "Function return type does not match operand " 2043 "type of return inst!", 2044 &RI, F->getReturnType()); 2045 2046 // Check to make sure that the return value has necessary properties for 2047 // terminators... 2048 visitTerminatorInst(RI); 2049} 2050 2051void Verifier::visitSwitchInst(SwitchInst &SI) { 2052 // Check to make sure that all of the constants in the switch instruction 2053 // have the same type as the switched-on value. 2054 Type *SwitchTy = SI.getCondition()->getType(); 2055 SmallPtrSet<ConstantInt*, 32> Constants; 2056 for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) { 2057 Assert(i.getCaseValue()->getType() == SwitchTy, 2058 "Switch constants must all be same type as switch value!", &SI); 2059 Assert(Constants.insert(i.getCaseValue()).second, 2060 "Duplicate integer as switch case", &SI, i.getCaseValue()); 2061 } 2062 2063 visitTerminatorInst(SI); 2064} 2065 2066void Verifier::visitIndirectBrInst(IndirectBrInst &BI) { 2067 Assert(BI.getAddress()->getType()->isPointerTy(), 2068 "Indirectbr operand must have pointer type!", &BI); 2069 for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i) 2070 Assert(BI.getDestination(i)->getType()->isLabelTy(), 2071 "Indirectbr destinations must all have pointer type!", &BI); 2072 2073 visitTerminatorInst(BI); 2074} 2075 2076void Verifier::visitSelectInst(SelectInst &SI) { 2077 Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1), 2078 SI.getOperand(2)), 2079 "Invalid operands for select instruction!", &SI); 2080 2081 Assert(SI.getTrueValue()->getType() == SI.getType(), 2082 "Select values must have same type as select instruction!", &SI); 2083 visitInstruction(SI); 2084} 2085 2086/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of 2087/// a pass, if any exist, it's an error. 2088/// 2089void Verifier::visitUserOp1(Instruction &I) { 2090 Assert(0, "User-defined operators should not live outside of a pass!", &I); 2091} 2092 2093void Verifier::visitTruncInst(TruncInst &I) { 2094 // Get the source and destination types 2095 Type *SrcTy = I.getOperand(0)->getType(); 2096 Type *DestTy = I.getType(); 2097 2098 // Get the size of the types in bits, we'll need this later 2099 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2100 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 2101 2102 Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I); 2103 Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I); 2104 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 2105 "trunc source and destination must both be a vector or neither", &I); 2106 Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I); 2107 2108 visitInstruction(I); 2109} 2110 2111void Verifier::visitZExtInst(ZExtInst &I) { 2112 // Get the source and destination types 2113 Type *SrcTy = I.getOperand(0)->getType(); 2114 Type *DestTy = I.getType(); 2115 2116 // Get the size of the types in bits, we'll need this later 2117 Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I); 2118 Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I); 2119 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 2120 "zext source and destination must both be a vector or neither", &I); 2121 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2122 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 2123 2124 Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I); 2125 2126 visitInstruction(I); 2127} 2128 2129void Verifier::visitSExtInst(SExtInst &I) { 2130 // Get the source and destination types 2131 Type *SrcTy = I.getOperand(0)->getType(); 2132 Type *DestTy = I.getType(); 2133 2134 // Get the size of the types in bits, we'll need this later 2135 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2136 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 2137 2138 Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I); 2139 Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I); 2140 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 2141 "sext source and destination must both be a vector or neither", &I); 2142 Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I); 2143 2144 visitInstruction(I); 2145} 2146 2147void Verifier::visitFPTruncInst(FPTruncInst &I) { 2148 // Get the source and destination types 2149 Type *SrcTy = I.getOperand(0)->getType(); 2150 Type *DestTy = I.getType(); 2151 // Get the size of the types in bits, we'll need this later 2152 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2153 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 2154 2155 Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I); 2156 Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I); 2157 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 2158 "fptrunc source and destination must both be a vector or neither", &I); 2159 Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I); 2160 2161 visitInstruction(I); 2162} 2163 2164void Verifier::visitFPExtInst(FPExtInst &I) { 2165 // Get the source and destination types 2166 Type *SrcTy = I.getOperand(0)->getType(); 2167 Type *DestTy = I.getType(); 2168 2169 // Get the size of the types in bits, we'll need this later 2170 unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 2171 unsigned DestBitSize = DestTy->getScalarSizeInBits(); 2172 2173 Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I); 2174 Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I); 2175 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), 2176 "fpext source and destination must both be a vector or neither", &I); 2177 Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I); 2178 2179 visitInstruction(I); 2180} 2181 2182void Verifier::visitUIToFPInst(UIToFPInst &I) { 2183 // Get the source and destination types 2184 Type *SrcTy = I.getOperand(0)->getType(); 2185 Type *DestTy = I.getType(); 2186 2187 bool SrcVec = SrcTy->isVectorTy(); 2188 bool DstVec = DestTy->isVectorTy(); 2189 2190 Assert(SrcVec == DstVec, 2191 "UIToFP source and dest must both be vector or scalar", &I); 2192 Assert(SrcTy->isIntOrIntVectorTy(), 2193 "UIToFP source must be integer or integer vector", &I); 2194 Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector", 2195 &I); 2196 2197 if (SrcVec && DstVec) 2198 Assert(cast<VectorType>(SrcTy)->getNumElements() == 2199 cast<VectorType>(DestTy)->getNumElements(), 2200 "UIToFP source and dest vector length mismatch", &I); 2201 2202 visitInstruction(I); 2203} 2204 2205void Verifier::visitSIToFPInst(SIToFPInst &I) { 2206 // Get the source and destination types 2207 Type *SrcTy = I.getOperand(0)->getType(); 2208 Type *DestTy = I.getType(); 2209 2210 bool SrcVec = SrcTy->isVectorTy(); 2211 bool DstVec = DestTy->isVectorTy(); 2212 2213 Assert(SrcVec == DstVec, 2214 "SIToFP source and dest must both be vector or scalar", &I); 2215 Assert(SrcTy->isIntOrIntVectorTy(), 2216 "SIToFP source must be integer or integer vector", &I); 2217 Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector", 2218 &I); 2219 2220 if (SrcVec && DstVec) 2221 Assert(cast<VectorType>(SrcTy)->getNumElements() == 2222 cast<VectorType>(DestTy)->getNumElements(), 2223 "SIToFP source and dest vector length mismatch", &I); 2224 2225 visitInstruction(I); 2226} 2227 2228void Verifier::visitFPToUIInst(FPToUIInst &I) { 2229 // Get the source and destination types 2230 Type *SrcTy = I.getOperand(0)->getType(); 2231 Type *DestTy = I.getType(); 2232 2233 bool SrcVec = SrcTy->isVectorTy(); 2234 bool DstVec = DestTy->isVectorTy(); 2235 2236 Assert(SrcVec == DstVec, 2237 "FPToUI source and dest must both be vector or scalar", &I); 2238 Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector", 2239 &I); 2240 Assert(DestTy->isIntOrIntVectorTy(), 2241 "FPToUI result must be integer or integer vector", &I); 2242 2243 if (SrcVec && DstVec) 2244 Assert(cast<VectorType>(SrcTy)->getNumElements() == 2245 cast<VectorType>(DestTy)->getNumElements(), 2246 "FPToUI source and dest vector length mismatch", &I); 2247 2248 visitInstruction(I); 2249} 2250 2251void Verifier::visitFPToSIInst(FPToSIInst &I) { 2252 // Get the source and destination types 2253 Type *SrcTy = I.getOperand(0)->getType(); 2254 Type *DestTy = I.getType(); 2255 2256 bool SrcVec = SrcTy->isVectorTy(); 2257 bool DstVec = DestTy->isVectorTy(); 2258 2259 Assert(SrcVec == DstVec, 2260 "FPToSI source and dest must both be vector or scalar", &I); 2261 Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector", 2262 &I); 2263 Assert(DestTy->isIntOrIntVectorTy(), 2264 "FPToSI result must be integer or integer vector", &I); 2265 2266 if (SrcVec && DstVec) 2267 Assert(cast<VectorType>(SrcTy)->getNumElements() == 2268 cast<VectorType>(DestTy)->getNumElements(), 2269 "FPToSI source and dest vector length mismatch", &I); 2270 2271 visitInstruction(I); 2272} 2273 2274void Verifier::visitPtrToIntInst(PtrToIntInst &I) { 2275 // Get the source and destination types 2276 Type *SrcTy = I.getOperand(0)->getType(); 2277 Type *DestTy = I.getType(); 2278 2279 Assert(SrcTy->getScalarType()->isPointerTy(), 2280 "PtrToInt source must be pointer", &I); 2281 Assert(DestTy->getScalarType()->isIntegerTy(), 2282 "PtrToInt result must be integral", &I); 2283 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch", 2284 &I); 2285 2286 if (SrcTy->isVectorTy()) { 2287 VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 2288 VectorType *VDest = dyn_cast<VectorType>(DestTy); 2289 Assert(VSrc->getNumElements() == VDest->getNumElements(), 2290 "PtrToInt Vector width mismatch", &I); 2291 } 2292 2293 visitInstruction(I); 2294} 2295 2296void Verifier::visitIntToPtrInst(IntToPtrInst &I) { 2297 // Get the source and destination types 2298 Type *SrcTy = I.getOperand(0)->getType(); 2299 Type *DestTy = I.getType(); 2300 2301 Assert(SrcTy->getScalarType()->isIntegerTy(), 2302 "IntToPtr source must be an integral", &I); 2303 Assert(DestTy->getScalarType()->isPointerTy(), 2304 "IntToPtr result must be a pointer", &I); 2305 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch", 2306 &I); 2307 if (SrcTy->isVectorTy()) { 2308 VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 2309 VectorType *VDest = dyn_cast<VectorType>(DestTy); 2310 Assert(VSrc->getNumElements() == VDest->getNumElements(), 2311 "IntToPtr Vector width mismatch", &I); 2312 } 2313 visitInstruction(I); 2314} 2315 2316void Verifier::visitBitCastInst(BitCastInst &I) { 2317 Assert( 2318 CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()), 2319 "Invalid bitcast", &I); 2320 visitInstruction(I); 2321} 2322 2323void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) { 2324 Type *SrcTy = I.getOperand(0)->getType(); 2325 Type *DestTy = I.getType(); 2326 2327 Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer", 2328 &I); 2329 Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer", 2330 &I); 2331 Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(), 2332 "AddrSpaceCast must be between different address spaces", &I); 2333 if (SrcTy->isVectorTy()) 2334 Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(), 2335 "AddrSpaceCast vector pointer number of elements mismatch", &I); 2336 visitInstruction(I); 2337} 2338 2339/// visitPHINode - Ensure that a PHI node is well formed. 2340/// 2341void Verifier::visitPHINode(PHINode &PN) { 2342 // Ensure that the PHI nodes are all grouped together at the top of the block. 2343 // This can be tested by checking whether the instruction before this is 2344 // either nonexistent (because this is begin()) or is a PHI node. If not, 2345 // then there is some other instruction before a PHI. 2346 Assert(&PN == &PN.getParent()->front() || 2347 isa<PHINode>(--BasicBlock::iterator(&PN)), 2348 "PHI nodes not grouped at top of basic block!", &PN, PN.getParent()); 2349 2350 // Check that a PHI doesn't yield a Token. 2351 Assert(!PN.getType()->isTokenTy(), "PHI nodes cannot have token type!"); 2352 2353 // Check that all of the values of the PHI node have the same type as the 2354 // result, and that the incoming blocks are really basic blocks. 2355 for (Value *IncValue : PN.incoming_values()) { 2356 Assert(PN.getType() == IncValue->getType(), 2357 "PHI node operands are not the same type as the result!", &PN); 2358 } 2359 2360 // All other PHI node constraints are checked in the visitBasicBlock method. 2361 2362 visitInstruction(PN); 2363} 2364 2365void Verifier::VerifyCallSite(CallSite CS) { 2366 Instruction *I = CS.getInstruction(); 2367 2368 Assert(CS.getCalledValue()->getType()->isPointerTy(), 2369 "Called function must be a pointer!", I); 2370 PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType()); 2371 2372 Assert(FPTy->getElementType()->isFunctionTy(), 2373 "Called function is not pointer to function type!", I); 2374 2375 Assert(FPTy->getElementType() == CS.getFunctionType(), 2376 "Called function is not the same type as the call!", I); 2377 2378 FunctionType *FTy = CS.getFunctionType(); 2379 2380 // Verify that the correct number of arguments are being passed 2381 if (FTy->isVarArg()) 2382 Assert(CS.arg_size() >= FTy->getNumParams(), 2383 "Called function requires more parameters than were provided!", I); 2384 else 2385 Assert(CS.arg_size() == FTy->getNumParams(), 2386 "Incorrect number of arguments passed to called function!", I); 2387 2388 // Verify that all arguments to the call match the function type. 2389 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) 2390 Assert(CS.getArgument(i)->getType() == FTy->getParamType(i), 2391 "Call parameter type does not match function signature!", 2392 CS.getArgument(i), FTy->getParamType(i), I); 2393 2394 AttributeSet Attrs = CS.getAttributes(); 2395 2396 Assert(VerifyAttributeCount(Attrs, CS.arg_size()), 2397 "Attribute after last parameter!", I); 2398 2399 // Verify call attributes. 2400 VerifyFunctionAttrs(FTy, Attrs, I); 2401 2402 // Conservatively check the inalloca argument. 2403 // We have a bug if we can find that there is an underlying alloca without 2404 // inalloca. 2405 if (CS.hasInAllocaArgument()) { 2406 Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1); 2407 if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets())) 2408 Assert(AI->isUsedWithInAlloca(), 2409 "inalloca argument for call has mismatched alloca", AI, I); 2410 } 2411 2412 if (FTy->isVarArg()) { 2413 // FIXME? is 'nest' even legal here? 2414 bool SawNest = false; 2415 bool SawReturned = false; 2416 2417 for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) { 2418 if (Attrs.hasAttribute(Idx, Attribute::Nest)) 2419 SawNest = true; 2420 if (Attrs.hasAttribute(Idx, Attribute::Returned)) 2421 SawReturned = true; 2422 } 2423 2424 // Check attributes on the varargs part. 2425 for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { 2426 Type *Ty = CS.getArgument(Idx-1)->getType(); 2427 VerifyParameterAttrs(Attrs, Idx, Ty, false, I); 2428 2429 if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 2430 Assert(!SawNest, "More than one parameter has attribute nest!", I); 2431 SawNest = true; 2432 } 2433 2434 if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 2435 Assert(!SawReturned, "More than one parameter has attribute returned!", 2436 I); 2437 Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()), 2438 "Incompatible argument and return types for 'returned' " 2439 "attribute", 2440 I); 2441 SawReturned = true; 2442 } 2443 2444 Assert(!Attrs.hasAttribute(Idx, Attribute::StructRet), 2445 "Attribute 'sret' cannot be used for vararg call arguments!", I); 2446 2447 if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) 2448 Assert(Idx == CS.arg_size(), "inalloca isn't on the last argument!", I); 2449 } 2450 } 2451 2452 // Verify that there's no metadata unless it's a direct call to an intrinsic. 2453 if (CS.getCalledFunction() == nullptr || 2454 !CS.getCalledFunction()->getName().startswith("llvm.")) { 2455 for (Type *ParamTy : FTy->params()) { 2456 Assert(!ParamTy->isMetadataTy(), 2457 "Function has metadata parameter but isn't an intrinsic", I); 2458 Assert(!ParamTy->isTokenTy(), 2459 "Function has token parameter but isn't an intrinsic", I); 2460 } 2461 } 2462 2463 // Verify that indirect calls don't return tokens. 2464 if (CS.getCalledFunction() == nullptr) 2465 Assert(!FTy->getReturnType()->isTokenTy(), 2466 "Return type cannot be token for indirect call!"); 2467 2468 if (Function *F = CS.getCalledFunction()) 2469 if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) 2470 visitIntrinsicCallSite(ID, CS); 2471 2472 // Verify that a callsite has at most one "deopt" and one "funclet" operand 2473 // bundle. 2474 bool FoundDeoptBundle = false, FoundFuncletBundle = false; 2475 for (unsigned i = 0, e = CS.getNumOperandBundles(); i < e; ++i) { 2476 OperandBundleUse BU = CS.getOperandBundleAt(i); 2477 uint32_t Tag = BU.getTagID(); 2478 if (Tag == LLVMContext::OB_deopt) { 2479 Assert(!FoundDeoptBundle, "Multiple deopt operand bundles", I); 2480 FoundDeoptBundle = true; 2481 } 2482 if (Tag == LLVMContext::OB_funclet) { 2483 Assert(!FoundFuncletBundle, "Multiple funclet operand bundles", I); 2484 FoundFuncletBundle = true; 2485 Assert(BU.Inputs.size() == 1, 2486 "Expected exactly one funclet bundle operand", I); 2487 Assert(isa<FuncletPadInst>(BU.Inputs.front()), 2488 "Funclet bundle operands should correspond to a FuncletPadInst", 2489 I); 2490 } 2491 } 2492 2493 visitInstruction(*I); 2494} 2495 2496/// Two types are "congruent" if they are identical, or if they are both pointer 2497/// types with different pointee types and the same address space. 2498static bool isTypeCongruent(Type *L, Type *R) { 2499 if (L == R) 2500 return true; 2501 PointerType *PL = dyn_cast<PointerType>(L); 2502 PointerType *PR = dyn_cast<PointerType>(R); 2503 if (!PL || !PR) 2504 return false; 2505 return PL->getAddressSpace() == PR->getAddressSpace(); 2506} 2507 2508static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs) { 2509 static const Attribute::AttrKind ABIAttrs[] = { 2510 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, 2511 Attribute::InReg, Attribute::Returned}; 2512 AttrBuilder Copy; 2513 for (auto AK : ABIAttrs) { 2514 if (Attrs.hasAttribute(I + 1, AK)) 2515 Copy.addAttribute(AK); 2516 } 2517 if (Attrs.hasAttribute(I + 1, Attribute::Alignment)) 2518 Copy.addAlignmentAttr(Attrs.getParamAlignment(I + 1)); 2519 return Copy; 2520} 2521 2522void Verifier::verifyMustTailCall(CallInst &CI) { 2523 Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI); 2524 2525 // - The caller and callee prototypes must match. Pointer types of 2526 // parameters or return types may differ in pointee type, but not 2527 // address space. 2528 Function *F = CI.getParent()->getParent(); 2529 FunctionType *CallerTy = F->getFunctionType(); 2530 FunctionType *CalleeTy = CI.getFunctionType(); 2531 Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(), 2532 "cannot guarantee tail call due to mismatched parameter counts", &CI); 2533 Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(), 2534 "cannot guarantee tail call due to mismatched varargs", &CI); 2535 Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()), 2536 "cannot guarantee tail call due to mismatched return types", &CI); 2537 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) { 2538 Assert( 2539 isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)), 2540 "cannot guarantee tail call due to mismatched parameter types", &CI); 2541 } 2542 2543 // - The calling conventions of the caller and callee must match. 2544 Assert(F->getCallingConv() == CI.getCallingConv(), 2545 "cannot guarantee tail call due to mismatched calling conv", &CI); 2546 2547 // - All ABI-impacting function attributes, such as sret, byval, inreg, 2548 // returned, and inalloca, must match. 2549 AttributeSet CallerAttrs = F->getAttributes(); 2550 AttributeSet CalleeAttrs = CI.getAttributes(); 2551 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) { 2552 AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs); 2553 AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs); 2554 Assert(CallerABIAttrs == CalleeABIAttrs, 2555 "cannot guarantee tail call due to mismatched ABI impacting " 2556 "function attributes", 2557 &CI, CI.getOperand(I)); 2558 } 2559 2560 // - The call must immediately precede a :ref:`ret <i_ret>` instruction, 2561 // or a pointer bitcast followed by a ret instruction. 2562 // - The ret instruction must return the (possibly bitcasted) value 2563 // produced by the call or void. 2564 Value *RetVal = &CI; 2565 Instruction *Next = CI.getNextNode(); 2566 2567 // Handle the optional bitcast. 2568 if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) { 2569 Assert(BI->getOperand(0) == RetVal, 2570 "bitcast following musttail call must use the call", BI); 2571 RetVal = BI; 2572 Next = BI->getNextNode(); 2573 } 2574 2575 // Check the return. 2576 ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next); 2577 Assert(Ret, "musttail call must be precede a ret with an optional bitcast", 2578 &CI); 2579 Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal, 2580 "musttail call result must be returned", Ret); 2581} 2582 2583void Verifier::visitCallInst(CallInst &CI) { 2584 VerifyCallSite(&CI); 2585 2586 if (CI.isMustTailCall()) 2587 verifyMustTailCall(CI); 2588} 2589 2590void Verifier::visitInvokeInst(InvokeInst &II) { 2591 VerifyCallSite(&II); 2592 2593 // Verify that the first non-PHI instruction of the unwind destination is an 2594 // exception handling instruction. 2595 Assert( 2596 II.getUnwindDest()->isEHPad(), 2597 "The unwind destination does not have an exception handling instruction!", 2598 &II); 2599 2600 visitTerminatorInst(II); 2601} 2602 2603/// visitBinaryOperator - Check that both arguments to the binary operator are 2604/// of the same type! 2605/// 2606void Verifier::visitBinaryOperator(BinaryOperator &B) { 2607 Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(), 2608 "Both operands to a binary operator are not of the same type!", &B); 2609 2610 switch (B.getOpcode()) { 2611 // Check that integer arithmetic operators are only used with 2612 // integral operands. 2613 case Instruction::Add: 2614 case Instruction::Sub: 2615 case Instruction::Mul: 2616 case Instruction::SDiv: 2617 case Instruction::UDiv: 2618 case Instruction::SRem: 2619 case Instruction::URem: 2620 Assert(B.getType()->isIntOrIntVectorTy(), 2621 "Integer arithmetic operators only work with integral types!", &B); 2622 Assert(B.getType() == B.getOperand(0)->getType(), 2623 "Integer arithmetic operators must have same type " 2624 "for operands and result!", 2625 &B); 2626 break; 2627 // Check that floating-point arithmetic operators are only used with 2628 // floating-point operands. 2629 case Instruction::FAdd: 2630 case Instruction::FSub: 2631 case Instruction::FMul: 2632 case Instruction::FDiv: 2633 case Instruction::FRem: 2634 Assert(B.getType()->isFPOrFPVectorTy(), 2635 "Floating-point arithmetic operators only work with " 2636 "floating-point types!", 2637 &B); 2638 Assert(B.getType() == B.getOperand(0)->getType(), 2639 "Floating-point arithmetic operators must have same type " 2640 "for operands and result!", 2641 &B); 2642 break; 2643 // Check that logical operators are only used with integral operands. 2644 case Instruction::And: 2645 case Instruction::Or: 2646 case Instruction::Xor: 2647 Assert(B.getType()->isIntOrIntVectorTy(), 2648 "Logical operators only work with integral types!", &B); 2649 Assert(B.getType() == B.getOperand(0)->getType(), 2650 "Logical operators must have same type for operands and result!", 2651 &B); 2652 break; 2653 case Instruction::Shl: 2654 case Instruction::LShr: 2655 case Instruction::AShr: 2656 Assert(B.getType()->isIntOrIntVectorTy(), 2657 "Shifts only work with integral types!", &B); 2658 Assert(B.getType() == B.getOperand(0)->getType(), 2659 "Shift return type must be same as operands!", &B); 2660 break; 2661 default: 2662 llvm_unreachable("Unknown BinaryOperator opcode!"); 2663 } 2664 2665 visitInstruction(B); 2666} 2667 2668void Verifier::visitICmpInst(ICmpInst &IC) { 2669 // Check that the operands are the same type 2670 Type *Op0Ty = IC.getOperand(0)->getType(); 2671 Type *Op1Ty = IC.getOperand(1)->getType(); 2672 Assert(Op0Ty == Op1Ty, 2673 "Both operands to ICmp instruction are not of the same type!", &IC); 2674 // Check that the operands are the right type 2675 Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(), 2676 "Invalid operand types for ICmp instruction", &IC); 2677 // Check that the predicate is valid. 2678 Assert(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE && 2679 IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE, 2680 "Invalid predicate in ICmp instruction!", &IC); 2681 2682 visitInstruction(IC); 2683} 2684 2685void Verifier::visitFCmpInst(FCmpInst &FC) { 2686 // Check that the operands are the same type 2687 Type *Op0Ty = FC.getOperand(0)->getType(); 2688 Type *Op1Ty = FC.getOperand(1)->getType(); 2689 Assert(Op0Ty == Op1Ty, 2690 "Both operands to FCmp instruction are not of the same type!", &FC); 2691 // Check that the operands are the right type 2692 Assert(Op0Ty->isFPOrFPVectorTy(), 2693 "Invalid operand types for FCmp instruction", &FC); 2694 // Check that the predicate is valid. 2695 Assert(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE && 2696 FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE, 2697 "Invalid predicate in FCmp instruction!", &FC); 2698 2699 visitInstruction(FC); 2700} 2701 2702void Verifier::visitExtractElementInst(ExtractElementInst &EI) { 2703 Assert( 2704 ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)), 2705 "Invalid extractelement operands!", &EI); 2706 visitInstruction(EI); 2707} 2708 2709void Verifier::visitInsertElementInst(InsertElementInst &IE) { 2710 Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1), 2711 IE.getOperand(2)), 2712 "Invalid insertelement operands!", &IE); 2713 visitInstruction(IE); 2714} 2715 2716void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { 2717 Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1), 2718 SV.getOperand(2)), 2719 "Invalid shufflevector operands!", &SV); 2720 visitInstruction(SV); 2721} 2722 2723void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { 2724 Type *TargetTy = GEP.getPointerOperandType()->getScalarType(); 2725 2726 Assert(isa<PointerType>(TargetTy), 2727 "GEP base pointer is not a vector or a vector of pointers", &GEP); 2728 Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP); 2729 SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end()); 2730 Type *ElTy = 2731 GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs); 2732 Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP); 2733 2734 Assert(GEP.getType()->getScalarType()->isPointerTy() && 2735 GEP.getResultElementType() == ElTy, 2736 "GEP is not of right type for indices!", &GEP, ElTy); 2737 2738 if (GEP.getType()->isVectorTy()) { 2739 // Additional checks for vector GEPs. 2740 unsigned GEPWidth = GEP.getType()->getVectorNumElements(); 2741 if (GEP.getPointerOperandType()->isVectorTy()) 2742 Assert(GEPWidth == GEP.getPointerOperandType()->getVectorNumElements(), 2743 "Vector GEP result width doesn't match operand's", &GEP); 2744 for (unsigned i = 0, e = Idxs.size(); i != e; ++i) { 2745 Type *IndexTy = Idxs[i]->getType(); 2746 if (IndexTy->isVectorTy()) { 2747 unsigned IndexWidth = IndexTy->getVectorNumElements(); 2748 Assert(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP); 2749 } 2750 Assert(IndexTy->getScalarType()->isIntegerTy(), 2751 "All GEP indices should be of integer type"); 2752 } 2753 } 2754 visitInstruction(GEP); 2755} 2756 2757static bool isContiguous(const ConstantRange &A, const ConstantRange &B) { 2758 return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); 2759} 2760 2761void Verifier::visitRangeMetadata(Instruction& I, 2762 MDNode* Range, Type* Ty) { 2763 assert(Range && 2764 Range == I.getMetadata(LLVMContext::MD_range) && 2765 "precondition violation"); 2766 2767 unsigned NumOperands = Range->getNumOperands(); 2768 Assert(NumOperands % 2 == 0, "Unfinished range!", Range); 2769 unsigned NumRanges = NumOperands / 2; 2770 Assert(NumRanges >= 1, "It should have at least one range!", Range); 2771 2772 ConstantRange LastRange(1); // Dummy initial value 2773 for (unsigned i = 0; i < NumRanges; ++i) { 2774 ConstantInt *Low = 2775 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i)); 2776 Assert(Low, "The lower limit must be an integer!", Low); 2777 ConstantInt *High = 2778 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1)); 2779 Assert(High, "The upper limit must be an integer!", High); 2780 Assert(High->getType() == Low->getType() && High->getType() == Ty, 2781 "Range types must match instruction type!", &I); 2782 2783 APInt HighV = High->getValue(); 2784 APInt LowV = Low->getValue(); 2785 ConstantRange CurRange(LowV, HighV); 2786 Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(), 2787 "Range must not be empty!", Range); 2788 if (i != 0) { 2789 Assert(CurRange.intersectWith(LastRange).isEmptySet(), 2790 "Intervals are overlapping", Range); 2791 Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order", 2792 Range); 2793 Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous", 2794 Range); 2795 } 2796 LastRange = ConstantRange(LowV, HighV); 2797 } 2798 if (NumRanges > 2) { 2799 APInt FirstLow = 2800 mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue(); 2801 APInt FirstHigh = 2802 mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue(); 2803 ConstantRange FirstRange(FirstLow, FirstHigh); 2804 Assert(FirstRange.intersectWith(LastRange).isEmptySet(), 2805 "Intervals are overlapping", Range); 2806 Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous", 2807 Range); 2808 } 2809} 2810 2811void Verifier::checkAtomicMemAccessSize(const Module *M, Type *Ty, 2812 const Instruction *I) { 2813 unsigned Size = M->getDataLayout().getTypeSizeInBits(Ty); 2814 Assert(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I); 2815 Assert(!(Size & (Size - 1)), 2816 "atomic memory access' operand must have a power-of-two size", Ty, I); 2817} 2818 2819void Verifier::visitLoadInst(LoadInst &LI) { 2820 PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType()); 2821 Assert(PTy, "Load operand must be a pointer.", &LI); 2822 Type *ElTy = LI.getType(); 2823 Assert(LI.getAlignment() <= Value::MaximumAlignment, 2824 "huge alignment values are unsupported", &LI); 2825 if (LI.isAtomic()) { 2826 Assert(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease, 2827 "Load cannot have Release ordering", &LI); 2828 Assert(LI.getAlignment() != 0, 2829 "Atomic load must specify explicit alignment", &LI); 2830 Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() || 2831 ElTy->isFloatingPointTy(), 2832 "atomic load operand must have integer, pointer, or floating point " 2833 "type!", 2834 ElTy, &LI); 2835 checkAtomicMemAccessSize(M, ElTy, &LI); 2836 } else { 2837 Assert(LI.getSynchScope() == CrossThread, 2838 "Non-atomic load cannot have SynchronizationScope specified", &LI); 2839 } 2840 2841 visitInstruction(LI); 2842} 2843 2844void Verifier::visitStoreInst(StoreInst &SI) { 2845 PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType()); 2846 Assert(PTy, "Store operand must be a pointer.", &SI); 2847 Type *ElTy = PTy->getElementType(); 2848 Assert(ElTy == SI.getOperand(0)->getType(), 2849 "Stored value type does not match pointer operand type!", &SI, ElTy); 2850 Assert(SI.getAlignment() <= Value::MaximumAlignment, 2851 "huge alignment values are unsupported", &SI); 2852 if (SI.isAtomic()) { 2853 Assert(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease, 2854 "Store cannot have Acquire ordering", &SI); 2855 Assert(SI.getAlignment() != 0, 2856 "Atomic store must specify explicit alignment", &SI); 2857 Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() || 2858 ElTy->isFloatingPointTy(), 2859 "atomic store operand must have integer, pointer, or floating point " 2860 "type!", 2861 ElTy, &SI); 2862 checkAtomicMemAccessSize(M, ElTy, &SI); 2863 } else { 2864 Assert(SI.getSynchScope() == CrossThread, 2865 "Non-atomic store cannot have SynchronizationScope specified", &SI); 2866 } 2867 visitInstruction(SI); 2868} 2869 2870void Verifier::visitAllocaInst(AllocaInst &AI) { 2871 SmallPtrSet<Type*, 4> Visited; 2872 PointerType *PTy = AI.getType(); 2873 Assert(PTy->getAddressSpace() == 0, 2874 "Allocation instruction pointer not in the generic address space!", 2875 &AI); 2876 Assert(AI.getAllocatedType()->isSized(&Visited), 2877 "Cannot allocate unsized type", &AI); 2878 Assert(AI.getArraySize()->getType()->isIntegerTy(), 2879 "Alloca array size must have integer type", &AI); 2880 Assert(AI.getAlignment() <= Value::MaximumAlignment, 2881 "huge alignment values are unsupported", &AI); 2882 2883 visitInstruction(AI); 2884} 2885 2886void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) { 2887 2888 // FIXME: more conditions??? 2889 Assert(CXI.getSuccessOrdering() != NotAtomic, 2890 "cmpxchg instructions must be atomic.", &CXI); 2891 Assert(CXI.getFailureOrdering() != NotAtomic, 2892 "cmpxchg instructions must be atomic.", &CXI); 2893 Assert(CXI.getSuccessOrdering() != Unordered, 2894 "cmpxchg instructions cannot be unordered.", &CXI); 2895 Assert(CXI.getFailureOrdering() != Unordered, 2896 "cmpxchg instructions cannot be unordered.", &CXI); 2897 Assert(CXI.getSuccessOrdering() >= CXI.getFailureOrdering(), 2898 "cmpxchg instructions be at least as constrained on success as fail", 2899 &CXI); 2900 Assert(CXI.getFailureOrdering() != Release && 2901 CXI.getFailureOrdering() != AcquireRelease, 2902 "cmpxchg failure ordering cannot include release semantics", &CXI); 2903 2904 PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType()); 2905 Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI); 2906 Type *ElTy = PTy->getElementType(); 2907 Assert(ElTy->isIntegerTy(), "cmpxchg operand must have integer type!", &CXI, 2908 ElTy); 2909 checkAtomicMemAccessSize(M, ElTy, &CXI); 2910 Assert(ElTy == CXI.getOperand(1)->getType(), 2911 "Expected value type does not match pointer operand type!", &CXI, 2912 ElTy); 2913 Assert(ElTy == CXI.getOperand(2)->getType(), 2914 "Stored value type does not match pointer operand type!", &CXI, ElTy); 2915 visitInstruction(CXI); 2916} 2917 2918void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) { 2919 Assert(RMWI.getOrdering() != NotAtomic, 2920 "atomicrmw instructions must be atomic.", &RMWI); 2921 Assert(RMWI.getOrdering() != Unordered, 2922 "atomicrmw instructions cannot be unordered.", &RMWI); 2923 PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType()); 2924 Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI); 2925 Type *ElTy = PTy->getElementType(); 2926 Assert(ElTy->isIntegerTy(), "atomicrmw operand must have integer type!", 2927 &RMWI, ElTy); 2928 checkAtomicMemAccessSize(M, ElTy, &RMWI); 2929 Assert(ElTy == RMWI.getOperand(1)->getType(), 2930 "Argument value type does not match pointer operand type!", &RMWI, 2931 ElTy); 2932 Assert(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() && 2933 RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP, 2934 "Invalid binary operation!", &RMWI); 2935 visitInstruction(RMWI); 2936} 2937 2938void Verifier::visitFenceInst(FenceInst &FI) { 2939 const AtomicOrdering Ordering = FI.getOrdering(); 2940 Assert(Ordering == Acquire || Ordering == Release || 2941 Ordering == AcquireRelease || Ordering == SequentiallyConsistent, 2942 "fence instructions may only have " 2943 "acquire, release, acq_rel, or seq_cst ordering.", 2944 &FI); 2945 visitInstruction(FI); 2946} 2947 2948void Verifier::visitExtractValueInst(ExtractValueInst &EVI) { 2949 Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(), 2950 EVI.getIndices()) == EVI.getType(), 2951 "Invalid ExtractValueInst operands!", &EVI); 2952 2953 visitInstruction(EVI); 2954} 2955 2956void Verifier::visitInsertValueInst(InsertValueInst &IVI) { 2957 Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(), 2958 IVI.getIndices()) == 2959 IVI.getOperand(1)->getType(), 2960 "Invalid InsertValueInst operands!", &IVI); 2961 2962 visitInstruction(IVI); 2963} 2964 2965static Value *getParentPad(Value *EHPad) { 2966 if (auto *FPI = dyn_cast<FuncletPadInst>(EHPad)) 2967 return FPI->getParentPad(); 2968 2969 return cast<CatchSwitchInst>(EHPad)->getParentPad(); 2970} 2971 2972void Verifier::visitEHPadPredecessors(Instruction &I) { 2973 assert(I.isEHPad()); 2974 2975 BasicBlock *BB = I.getParent(); 2976 Function *F = BB->getParent(); 2977 2978 Assert(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I); 2979 2980 if (auto *LPI = dyn_cast<LandingPadInst>(&I)) { 2981 // The landingpad instruction defines its parent as a landing pad block. The 2982 // landing pad block may be branched to only by the unwind edge of an 2983 // invoke. 2984 for (BasicBlock *PredBB : predecessors(BB)) { 2985 const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator()); 2986 Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB, 2987 "Block containing LandingPadInst must be jumped to " 2988 "only by the unwind edge of an invoke.", 2989 LPI); 2990 } 2991 return; 2992 } 2993 if (auto *CPI = dyn_cast<CatchPadInst>(&I)) { 2994 if (!pred_empty(BB)) 2995 Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(), 2996 "Block containg CatchPadInst must be jumped to " 2997 "only by its catchswitch.", 2998 CPI); 2999 Assert(BB != CPI->getCatchSwitch()->getUnwindDest(), 3000 "Catchswitch cannot unwind to one of its catchpads", 3001 CPI->getCatchSwitch(), CPI); 3002 return; 3003 } 3004 3005 // Verify that each pred has a legal terminator with a legal to/from EH 3006 // pad relationship. 3007 Instruction *ToPad = &I; 3008 Value *ToPadParent = getParentPad(ToPad); 3009 for (BasicBlock *PredBB : predecessors(BB)) { 3010 TerminatorInst *TI = PredBB->getTerminator(); 3011 Value *FromPad; 3012 if (auto *II = dyn_cast<InvokeInst>(TI)) { 3013 Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB, 3014 "EH pad must be jumped to via an unwind edge", ToPad, II); 3015 if (auto Bundle = II->getOperandBundle(LLVMContext::OB_funclet)) 3016 FromPad = Bundle->Inputs[0]; 3017 else 3018 FromPad = ConstantTokenNone::get(II->getContext()); 3019 } else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) { 3020 FromPad = CRI->getCleanupPad(); 3021 Assert(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI); 3022 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(TI)) { 3023 FromPad = CSI; 3024 } else { 3025 Assert(false, "EH pad must be jumped to via an unwind edge", ToPad, TI); 3026 } 3027 3028 // The edge may exit from zero or more nested pads. 3029 for (;; FromPad = getParentPad(FromPad)) { 3030 Assert(FromPad != ToPad, 3031 "EH pad cannot handle exceptions raised within it", FromPad, TI); 3032 if (FromPad == ToPadParent) { 3033 // This is a legal unwind edge. 3034 break; 3035 } 3036 Assert(!isa<ConstantTokenNone>(FromPad), 3037 "A single unwind edge may only enter one EH pad", TI); 3038 } 3039 } 3040} 3041 3042void Verifier::visitLandingPadInst(LandingPadInst &LPI) { 3043 // The landingpad instruction is ill-formed if it doesn't have any clauses and 3044 // isn't a cleanup. 3045 Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(), 3046 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI); 3047 3048 visitEHPadPredecessors(LPI); 3049 3050 if (!LandingPadResultTy) 3051 LandingPadResultTy = LPI.getType(); 3052 else 3053 Assert(LandingPadResultTy == LPI.getType(), 3054 "The landingpad instruction should have a consistent result type " 3055 "inside a function.", 3056 &LPI); 3057 3058 Function *F = LPI.getParent()->getParent(); 3059 Assert(F->hasPersonalityFn(), 3060 "LandingPadInst needs to be in a function with a personality.", &LPI); 3061 3062 // The landingpad instruction must be the first non-PHI instruction in the 3063 // block. 3064 Assert(LPI.getParent()->getLandingPadInst() == &LPI, 3065 "LandingPadInst not the first non-PHI instruction in the block.", 3066 &LPI); 3067 3068 for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) { 3069 Constant *Clause = LPI.getClause(i); 3070 if (LPI.isCatch(i)) { 3071 Assert(isa<PointerType>(Clause->getType()), 3072 "Catch operand does not have pointer type!", &LPI); 3073 } else { 3074 Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI); 3075 Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause), 3076 "Filter operand is not an array of constants!", &LPI); 3077 } 3078 } 3079 3080 visitInstruction(LPI); 3081} 3082 3083void Verifier::visitCatchPadInst(CatchPadInst &CPI) { 3084 visitEHPadPredecessors(CPI); 3085 3086 BasicBlock *BB = CPI.getParent(); 3087 3088 Function *F = BB->getParent(); 3089 Assert(F->hasPersonalityFn(), 3090 "CatchPadInst needs to be in a function with a personality.", &CPI); 3091 3092 Assert(isa<CatchSwitchInst>(CPI.getParentPad()), 3093 "CatchPadInst needs to be directly nested in a CatchSwitchInst.", 3094 CPI.getParentPad()); 3095 3096 // The catchpad instruction must be the first non-PHI instruction in the 3097 // block. 3098 Assert(BB->getFirstNonPHI() == &CPI, 3099 "CatchPadInst not the first non-PHI instruction in the block.", &CPI); 3100 3101 visitFuncletPadInst(CPI); 3102} 3103 3104void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) { 3105 Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)), 3106 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn, 3107 CatchReturn.getOperand(0)); 3108 3109 visitTerminatorInst(CatchReturn); 3110} 3111 3112void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) { 3113 visitEHPadPredecessors(CPI); 3114 3115 BasicBlock *BB = CPI.getParent(); 3116 3117 Function *F = BB->getParent(); 3118 Assert(F->hasPersonalityFn(), 3119 "CleanupPadInst needs to be in a function with a personality.", &CPI); 3120 3121 // The cleanuppad instruction must be the first non-PHI instruction in the 3122 // block. 3123 Assert(BB->getFirstNonPHI() == &CPI, 3124 "CleanupPadInst not the first non-PHI instruction in the block.", 3125 &CPI); 3126 3127 auto *ParentPad = CPI.getParentPad(); 3128 Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad), 3129 "CleanupPadInst has an invalid parent.", &CPI); 3130 3131 visitFuncletPadInst(CPI); 3132} 3133 3134void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) { 3135 User *FirstUser = nullptr; 3136 Value *FirstUnwindPad = nullptr; 3137 SmallVector<FuncletPadInst *, 8> Worklist({&FPI}); 3138 while (!Worklist.empty()) { 3139 FuncletPadInst *CurrentPad = Worklist.pop_back_val(); 3140 Value *UnresolvedAncestorPad = nullptr; 3141 for (User *U : CurrentPad->users()) { 3142 BasicBlock *UnwindDest; 3143 if (auto *CRI = dyn_cast<CleanupReturnInst>(U)) { 3144 UnwindDest = CRI->getUnwindDest(); 3145 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(U)) { 3146 // We allow catchswitch unwind to caller to nest 3147 // within an outer pad that unwinds somewhere else, 3148 // because catchswitch doesn't have a nounwind variant. 3149 // See e.g. SimplifyCFGOpt::SimplifyUnreachable. 3150 if (CSI->unwindsToCaller()) 3151 continue; 3152 UnwindDest = CSI->getUnwindDest(); 3153 } else if (auto *II = dyn_cast<InvokeInst>(U)) { 3154 UnwindDest = II->getUnwindDest(); 3155 } else if (isa<CallInst>(U)) { 3156 // Calls which don't unwind may be found inside funclet 3157 // pads that unwind somewhere else. We don't *require* 3158 // such calls to be annotated nounwind. 3159 continue; 3160 } else if (auto *CPI = dyn_cast<CleanupPadInst>(U)) { 3161 // The unwind dest for a cleanup can only be found by 3162 // recursive search. Add it to the worklist, and we'll 3163 // search for its first use that determines where it unwinds. 3164 Worklist.push_back(CPI); 3165 continue; 3166 } else { 3167 Assert(isa<CatchReturnInst>(U), "Bogus funclet pad use", U); 3168 continue; 3169 } 3170 3171 Value *UnwindPad; 3172 bool ExitsFPI; 3173 if (UnwindDest) { 3174 UnwindPad = UnwindDest->getFirstNonPHI(); 3175 Value *UnwindParent = getParentPad(UnwindPad); 3176 // Ignore unwind edges that don't exit CurrentPad. 3177 if (UnwindParent == CurrentPad) 3178 continue; 3179 // Determine whether the original funclet pad is exited, 3180 // and if we are scanning nested pads determine how many 3181 // of them are exited so we can stop searching their 3182 // children. 3183 Value *ExitedPad = CurrentPad; 3184 ExitsFPI = false; 3185 do { 3186 if (ExitedPad == &FPI) { 3187 ExitsFPI = true; 3188 // Now we can resolve any ancestors of CurrentPad up to 3189 // FPI, but not including FPI since we need to make sure 3190 // to check all direct users of FPI for consistency. 3191 UnresolvedAncestorPad = &FPI; 3192 break; 3193 } 3194 Value *ExitedParent = getParentPad(ExitedPad); 3195 if (ExitedParent == UnwindParent) { 3196 // ExitedPad is the ancestor-most pad which this unwind 3197 // edge exits, so we can resolve up to it, meaning that 3198 // ExitedParent is the first ancestor still unresolved. 3199 UnresolvedAncestorPad = ExitedParent; 3200 break; 3201 } 3202 ExitedPad = ExitedParent; 3203 } while (!isa<ConstantTokenNone>(ExitedPad)); 3204 } else { 3205 // Unwinding to caller exits all pads. 3206 UnwindPad = ConstantTokenNone::get(FPI.getContext()); 3207 ExitsFPI = true; 3208 UnresolvedAncestorPad = &FPI; 3209 } 3210 3211 if (ExitsFPI) { 3212 // This unwind edge exits FPI. Make sure it agrees with other 3213 // such edges. 3214 if (FirstUser) { 3215 Assert(UnwindPad == FirstUnwindPad, "Unwind edges out of a funclet " 3216 "pad must have the same unwind " 3217 "dest", 3218 &FPI, U, FirstUser); 3219 } else { 3220 FirstUser = U; 3221 FirstUnwindPad = UnwindPad; 3222 // Record cleanup sibling unwinds for verifySiblingFuncletUnwinds 3223 if (isa<CleanupPadInst>(&FPI) && !isa<ConstantTokenNone>(UnwindPad) && 3224 getParentPad(UnwindPad) == getParentPad(&FPI)) 3225 SiblingFuncletInfo[&FPI] = cast<TerminatorInst>(U); 3226 } 3227 } 3228 // Make sure we visit all uses of FPI, but for nested pads stop as 3229 // soon as we know where they unwind to. 3230 if (CurrentPad != &FPI) 3231 break; 3232 } 3233 if (UnresolvedAncestorPad) { 3234 if (CurrentPad == UnresolvedAncestorPad) { 3235 // When CurrentPad is FPI itself, we don't mark it as resolved even if 3236 // we've found an unwind edge that exits it, because we need to verify 3237 // all direct uses of FPI. 3238 assert(CurrentPad == &FPI); 3239 continue; 3240 } 3241 // Pop off the worklist any nested pads that we've found an unwind 3242 // destination for. The pads on the worklist are the uncles, 3243 // great-uncles, etc. of CurrentPad. We've found an unwind destination 3244 // for all ancestors of CurrentPad up to but not including 3245 // UnresolvedAncestorPad. 3246 Value *ResolvedPad = CurrentPad; 3247 while (!Worklist.empty()) { 3248 Value *UnclePad = Worklist.back(); 3249 Value *AncestorPad = getParentPad(UnclePad); 3250 // Walk ResolvedPad up the ancestor list until we either find the 3251 // uncle's parent or the last resolved ancestor. 3252 while (ResolvedPad != AncestorPad) { 3253 Value *ResolvedParent = getParentPad(ResolvedPad); 3254 if (ResolvedParent == UnresolvedAncestorPad) { 3255 break; 3256 } 3257 ResolvedPad = ResolvedParent; 3258 } 3259 // If the resolved ancestor search didn't find the uncle's parent, 3260 // then the uncle is not yet resolved. 3261 if (ResolvedPad != AncestorPad) 3262 break; 3263 // This uncle is resolved, so pop it from the worklist. 3264 Worklist.pop_back(); 3265 } 3266 } 3267 } 3268 3269 if (FirstUnwindPad) { 3270 if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FPI.getParentPad())) { 3271 BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest(); 3272 Value *SwitchUnwindPad; 3273 if (SwitchUnwindDest) 3274 SwitchUnwindPad = SwitchUnwindDest->getFirstNonPHI(); 3275 else 3276 SwitchUnwindPad = ConstantTokenNone::get(FPI.getContext()); 3277 Assert(SwitchUnwindPad == FirstUnwindPad, 3278 "Unwind edges out of a catch must have the same unwind dest as " 3279 "the parent catchswitch", 3280 &FPI, FirstUser, CatchSwitch); 3281 } 3282 } 3283 3284 visitInstruction(FPI); 3285} 3286 3287void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) { 3288 visitEHPadPredecessors(CatchSwitch); 3289 3290 BasicBlock *BB = CatchSwitch.getParent(); 3291 3292 Function *F = BB->getParent(); 3293 Assert(F->hasPersonalityFn(), 3294 "CatchSwitchInst needs to be in a function with a personality.", 3295 &CatchSwitch); 3296 3297 // The catchswitch instruction must be the first non-PHI instruction in the 3298 // block. 3299 Assert(BB->getFirstNonPHI() == &CatchSwitch, 3300 "CatchSwitchInst not the first non-PHI instruction in the block.", 3301 &CatchSwitch); 3302 3303 auto *ParentPad = CatchSwitch.getParentPad(); 3304 Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad), 3305 "CatchSwitchInst has an invalid parent.", ParentPad); 3306 3307 if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) { 3308 Instruction *I = UnwindDest->getFirstNonPHI(); 3309 Assert(I->isEHPad() && !isa<LandingPadInst>(I), 3310 "CatchSwitchInst must unwind to an EH block which is not a " 3311 "landingpad.", 3312 &CatchSwitch); 3313 3314 // Record catchswitch sibling unwinds for verifySiblingFuncletUnwinds 3315 if (getParentPad(I) == ParentPad) 3316 SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch; 3317 } 3318 3319 Assert(CatchSwitch.getNumHandlers() != 0, 3320 "CatchSwitchInst cannot have empty handler list", &CatchSwitch); 3321 3322 for (BasicBlock *Handler : CatchSwitch.handlers()) { 3323 Assert(isa<CatchPadInst>(Handler->getFirstNonPHI()), 3324 "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler); 3325 } 3326 3327 visitTerminatorInst(CatchSwitch); 3328} 3329 3330void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) { 3331 Assert(isa<CleanupPadInst>(CRI.getOperand(0)), 3332 "CleanupReturnInst needs to be provided a CleanupPad", &CRI, 3333 CRI.getOperand(0)); 3334 3335 if (BasicBlock *UnwindDest = CRI.getUnwindDest()) { 3336 Instruction *I = UnwindDest->getFirstNonPHI(); 3337 Assert(I->isEHPad() && !isa<LandingPadInst>(I), 3338 "CleanupReturnInst must unwind to an EH block which is not a " 3339 "landingpad.", 3340 &CRI); 3341 } 3342 3343 visitTerminatorInst(CRI); 3344} 3345 3346void Verifier::verifyDominatesUse(Instruction &I, unsigned i) { 3347 Instruction *Op = cast<Instruction>(I.getOperand(i)); 3348 // If the we have an invalid invoke, don't try to compute the dominance. 3349 // We already reject it in the invoke specific checks and the dominance 3350 // computation doesn't handle multiple edges. 3351 if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) { 3352 if (II->getNormalDest() == II->getUnwindDest()) 3353 return; 3354 } 3355 3356 const Use &U = I.getOperandUse(i); 3357 Assert(InstsInThisBlock.count(Op) || DT.dominates(Op, U), 3358 "Instruction does not dominate all uses!", Op, &I); 3359} 3360 3361void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) { 3362 Assert(I.getType()->isPointerTy(), "dereferenceable, dereferenceable_or_null " 3363 "apply only to pointer types", &I); 3364 Assert(isa<LoadInst>(I), 3365 "dereferenceable, dereferenceable_or_null apply only to load" 3366 " instructions, use attributes for calls or invokes", &I); 3367 Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null " 3368 "take one operand!", &I); 3369 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0)); 3370 Assert(CI && CI->getType()->isIntegerTy(64), "dereferenceable, " 3371 "dereferenceable_or_null metadata value must be an i64!", &I); 3372} 3373 3374/// verifyInstruction - Verify that an instruction is well formed. 3375/// 3376void Verifier::visitInstruction(Instruction &I) { 3377 BasicBlock *BB = I.getParent(); 3378 Assert(BB, "Instruction not embedded in basic block!", &I); 3379 3380 if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential 3381 for (User *U : I.users()) { 3382 Assert(U != (User *)&I || !DT.isReachableFromEntry(BB), 3383 "Only PHI nodes may reference their own value!", &I); 3384 } 3385 } 3386 3387 // Check that void typed values don't have names 3388 Assert(!I.getType()->isVoidTy() || !I.hasName(), 3389 "Instruction has a name, but provides a void value!", &I); 3390 3391 // Check that the return value of the instruction is either void or a legal 3392 // value type. 3393 Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(), 3394 "Instruction returns a non-scalar type!", &I); 3395 3396 // Check that the instruction doesn't produce metadata. Calls are already 3397 // checked against the callee type. 3398 Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I), 3399 "Invalid use of metadata!", &I); 3400 3401 // Check that all uses of the instruction, if they are instructions 3402 // themselves, actually have parent basic blocks. If the use is not an 3403 // instruction, it is an error! 3404 for (Use &U : I.uses()) { 3405 if (Instruction *Used = dyn_cast<Instruction>(U.getUser())) 3406 Assert(Used->getParent() != nullptr, 3407 "Instruction referencing" 3408 " instruction not embedded in a basic block!", 3409 &I, Used); 3410 else { 3411 CheckFailed("Use of instruction is not an instruction!", U); 3412 return; 3413 } 3414 } 3415 3416 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 3417 Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I); 3418 3419 // Check to make sure that only first-class-values are operands to 3420 // instructions. 3421 if (!I.getOperand(i)->getType()->isFirstClassType()) { 3422 Assert(0, "Instruction operands must be first-class values!", &I); 3423 } 3424 3425 if (Function *F = dyn_cast<Function>(I.getOperand(i))) { 3426 // Check to make sure that the "address of" an intrinsic function is never 3427 // taken. 3428 Assert( 3429 !F->isIntrinsic() || 3430 i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0), 3431 "Cannot take the address of an intrinsic!", &I); 3432 Assert( 3433 !F->isIntrinsic() || isa<CallInst>(I) || 3434 F->getIntrinsicID() == Intrinsic::donothing || 3435 F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void || 3436 F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 || 3437 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint, 3438 "Cannot invoke an intrinsinc other than" 3439 " donothing or patchpoint", 3440 &I); 3441 Assert(F->getParent() == M, "Referencing function in another module!", 3442 &I, M, F, F->getParent()); 3443 } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) { 3444 Assert(OpBB->getParent() == BB->getParent(), 3445 "Referring to a basic block in another function!", &I); 3446 } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) { 3447 Assert(OpArg->getParent() == BB->getParent(), 3448 "Referring to an argument in another function!", &I); 3449 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) { 3450 Assert(GV->getParent() == M, "Referencing global in another module!", &I, M, GV, GV->getParent()); 3451 } else if (isa<Instruction>(I.getOperand(i))) { 3452 verifyDominatesUse(I, i); 3453 } else if (isa<InlineAsm>(I.getOperand(i))) { 3454 Assert((i + 1 == e && isa<CallInst>(I)) || 3455 (i + 3 == e && isa<InvokeInst>(I)), 3456 "Cannot take the address of an inline asm!", &I); 3457 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) { 3458 if (CE->getType()->isPtrOrPtrVectorTy()) { 3459 // If we have a ConstantExpr pointer, we need to see if it came from an 3460 // illegal bitcast (inttoptr <constant int> ) 3461 visitConstantExprsRecursively(CE); 3462 } 3463 } 3464 } 3465 3466 if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) { 3467 Assert(I.getType()->isFPOrFPVectorTy(), 3468 "fpmath requires a floating point result!", &I); 3469 Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I); 3470 if (ConstantFP *CFP0 = 3471 mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) { 3472 APFloat Accuracy = CFP0->getValueAPF(); 3473 Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(), 3474 "fpmath accuracy not a positive number!", &I); 3475 } else { 3476 Assert(false, "invalid fpmath accuracy!", &I); 3477 } 3478 } 3479 3480 if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) { 3481 Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I), 3482 "Ranges are only for loads, calls and invokes!", &I); 3483 visitRangeMetadata(I, Range, I.getType()); 3484 } 3485 3486 if (I.getMetadata(LLVMContext::MD_nonnull)) { 3487 Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types", 3488 &I); 3489 Assert(isa<LoadInst>(I), 3490 "nonnull applies only to load instructions, use attributes" 3491 " for calls or invokes", 3492 &I); 3493 } 3494 3495 if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable)) 3496 visitDereferenceableMetadata(I, MD); 3497 3498 if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null)) 3499 visitDereferenceableMetadata(I, MD); 3500 3501 if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) { 3502 Assert(I.getType()->isPointerTy(), "align applies only to pointer types", 3503 &I); 3504 Assert(isa<LoadInst>(I), "align applies only to load instructions, " 3505 "use attributes for calls or invokes", &I); 3506 Assert(AlignMD->getNumOperands() == 1, "align takes one operand!", &I); 3507 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0)); 3508 Assert(CI && CI->getType()->isIntegerTy(64), 3509 "align metadata value must be an i64!", &I); 3510 uint64_t Align = CI->getZExtValue(); 3511 Assert(isPowerOf2_64(Align), 3512 "align metadata value must be a power of 2!", &I); 3513 Assert(Align <= Value::MaximumAlignment, 3514 "alignment is larger that implementation defined limit", &I); 3515 } 3516 3517 if (MDNode *N = I.getDebugLoc().getAsMDNode()) { 3518 Assert(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N); 3519 visitMDNode(*N); 3520 } 3521 3522 InstsInThisBlock.insert(&I); 3523} 3524 3525/// VerifyIntrinsicType - Verify that the specified type (which comes from an 3526/// intrinsic argument or return value) matches the type constraints specified 3527/// by the .td file (e.g. an "any integer" argument really is an integer). 3528/// 3529/// This return true on error but does not print a message. 3530bool Verifier::VerifyIntrinsicType(Type *Ty, 3531 ArrayRef<Intrinsic::IITDescriptor> &Infos, 3532 SmallVectorImpl<Type*> &ArgTys) { 3533 using namespace Intrinsic; 3534 3535 // If we ran out of descriptors, there are too many arguments. 3536 if (Infos.empty()) return true; 3537 IITDescriptor D = Infos.front(); 3538 Infos = Infos.slice(1); 3539 3540 switch (D.Kind) { 3541 case IITDescriptor::Void: return !Ty->isVoidTy(); 3542 case IITDescriptor::VarArg: return true; 3543 case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); 3544 case IITDescriptor::Token: return !Ty->isTokenTy(); 3545 case IITDescriptor::Metadata: return !Ty->isMetadataTy(); 3546 case IITDescriptor::Half: return !Ty->isHalfTy(); 3547 case IITDescriptor::Float: return !Ty->isFloatTy(); 3548 case IITDescriptor::Double: return !Ty->isDoubleTy(); 3549 case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width); 3550 case IITDescriptor::Vector: { 3551 VectorType *VT = dyn_cast<VectorType>(Ty); 3552 return !VT || VT->getNumElements() != D.Vector_Width || 3553 VerifyIntrinsicType(VT->getElementType(), Infos, ArgTys); 3554 } 3555 case IITDescriptor::Pointer: { 3556 PointerType *PT = dyn_cast<PointerType>(Ty); 3557 return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace || 3558 VerifyIntrinsicType(PT->getElementType(), Infos, ArgTys); 3559 } 3560 3561 case IITDescriptor::Struct: { 3562 StructType *ST = dyn_cast<StructType>(Ty); 3563 if (!ST || ST->getNumElements() != D.Struct_NumElements) 3564 return true; 3565 3566 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 3567 if (VerifyIntrinsicType(ST->getElementType(i), Infos, ArgTys)) 3568 return true; 3569 return false; 3570 } 3571 3572 case IITDescriptor::Argument: 3573 // Two cases here - If this is the second occurrence of an argument, verify 3574 // that the later instance matches the previous instance. 3575 if (D.getArgumentNumber() < ArgTys.size()) 3576 return Ty != ArgTys[D.getArgumentNumber()]; 3577 3578 // Otherwise, if this is the first instance of an argument, record it and 3579 // verify the "Any" kind. 3580 assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error"); 3581 ArgTys.push_back(Ty); 3582 3583 switch (D.getArgumentKind()) { 3584 case IITDescriptor::AK_Any: return false; // Success 3585 case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy(); 3586 case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy(); 3587 case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty); 3588 case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty); 3589 } 3590 llvm_unreachable("all argument kinds not covered"); 3591 3592 case IITDescriptor::ExtendArgument: { 3593 // This may only be used when referring to a previous vector argument. 3594 if (D.getArgumentNumber() >= ArgTys.size()) 3595 return true; 3596 3597 Type *NewTy = ArgTys[D.getArgumentNumber()]; 3598 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 3599 NewTy = VectorType::getExtendedElementVectorType(VTy); 3600 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 3601 NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth()); 3602 else 3603 return true; 3604 3605 return Ty != NewTy; 3606 } 3607 case IITDescriptor::TruncArgument: { 3608 // This may only be used when referring to a previous vector argument. 3609 if (D.getArgumentNumber() >= ArgTys.size()) 3610 return true; 3611 3612 Type *NewTy = ArgTys[D.getArgumentNumber()]; 3613 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 3614 NewTy = VectorType::getTruncatedElementVectorType(VTy); 3615 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 3616 NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2); 3617 else 3618 return true; 3619 3620 return Ty != NewTy; 3621 } 3622 case IITDescriptor::HalfVecArgument: 3623 // This may only be used when referring to a previous vector argument. 3624 return D.getArgumentNumber() >= ArgTys.size() || 3625 !isa<VectorType>(ArgTys[D.getArgumentNumber()]) || 3626 VectorType::getHalfElementsVectorType( 3627 cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty; 3628 case IITDescriptor::SameVecWidthArgument: { 3629 if (D.getArgumentNumber() >= ArgTys.size()) 3630 return true; 3631 VectorType * ReferenceType = 3632 dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]); 3633 VectorType *ThisArgType = dyn_cast<VectorType>(Ty); 3634 if (!ThisArgType || !ReferenceType || 3635 (ReferenceType->getVectorNumElements() != 3636 ThisArgType->getVectorNumElements())) 3637 return true; 3638 return VerifyIntrinsicType(ThisArgType->getVectorElementType(), 3639 Infos, ArgTys); 3640 } 3641 case IITDescriptor::PtrToArgument: { 3642 if (D.getArgumentNumber() >= ArgTys.size()) 3643 return true; 3644 Type * ReferenceType = ArgTys[D.getArgumentNumber()]; 3645 PointerType *ThisArgType = dyn_cast<PointerType>(Ty); 3646 return (!ThisArgType || ThisArgType->getElementType() != ReferenceType); 3647 } 3648 case IITDescriptor::VecOfPtrsToElt: { 3649 if (D.getArgumentNumber() >= ArgTys.size()) 3650 return true; 3651 VectorType * ReferenceType = 3652 dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]); 3653 VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty); 3654 if (!ThisArgVecTy || !ReferenceType || 3655 (ReferenceType->getVectorNumElements() != 3656 ThisArgVecTy->getVectorNumElements())) 3657 return true; 3658 PointerType *ThisArgEltTy = 3659 dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType()); 3660 if (!ThisArgEltTy) 3661 return true; 3662 return ThisArgEltTy->getElementType() != 3663 ReferenceType->getVectorElementType(); 3664 } 3665 } 3666 llvm_unreachable("unhandled"); 3667} 3668 3669/// \brief Verify if the intrinsic has variable arguments. 3670/// This method is intended to be called after all the fixed arguments have been 3671/// verified first. 3672/// 3673/// This method returns true on error and does not print an error message. 3674bool 3675Verifier::VerifyIntrinsicIsVarArg(bool isVarArg, 3676 ArrayRef<Intrinsic::IITDescriptor> &Infos) { 3677 using namespace Intrinsic; 3678 3679 // If there are no descriptors left, then it can't be a vararg. 3680 if (Infos.empty()) 3681 return isVarArg; 3682 3683 // There should be only one descriptor remaining at this point. 3684 if (Infos.size() != 1) 3685 return true; 3686 3687 // Check and verify the descriptor. 3688 IITDescriptor D = Infos.front(); 3689 Infos = Infos.slice(1); 3690 if (D.Kind == IITDescriptor::VarArg) 3691 return !isVarArg; 3692 3693 return true; 3694} 3695 3696/// Allow intrinsics to be verified in different ways. 3697void Verifier::visitIntrinsicCallSite(Intrinsic::ID ID, CallSite CS) { 3698 Function *IF = CS.getCalledFunction(); 3699 Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!", 3700 IF); 3701 3702 // Verify that the intrinsic prototype lines up with what the .td files 3703 // describe. 3704 FunctionType *IFTy = IF->getFunctionType(); 3705 bool IsVarArg = IFTy->isVarArg(); 3706 3707 SmallVector<Intrinsic::IITDescriptor, 8> Table; 3708 getIntrinsicInfoTableEntries(ID, Table); 3709 ArrayRef<Intrinsic::IITDescriptor> TableRef = Table; 3710 3711 SmallVector<Type *, 4> ArgTys; 3712 Assert(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys), 3713 "Intrinsic has incorrect return type!", IF); 3714 for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i) 3715 Assert(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys), 3716 "Intrinsic has incorrect argument type!", IF); 3717 3718 // Verify if the intrinsic call matches the vararg property. 3719 if (IsVarArg) 3720 Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 3721 "Intrinsic was not defined with variable arguments!", IF); 3722 else 3723 Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 3724 "Callsite was not defined with variable arguments!", IF); 3725 3726 // All descriptors should be absorbed by now. 3727 Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF); 3728 3729 // Now that we have the intrinsic ID and the actual argument types (and we 3730 // know they are legal for the intrinsic!) get the intrinsic name through the 3731 // usual means. This allows us to verify the mangling of argument types into 3732 // the name. 3733 const std::string ExpectedName = Intrinsic::getName(ID, ArgTys); 3734 Assert(ExpectedName == IF->getName(), 3735 "Intrinsic name not mangled correctly for type arguments! " 3736 "Should be: " + 3737 ExpectedName, 3738 IF); 3739 3740 // If the intrinsic takes MDNode arguments, verify that they are either global 3741 // or are local to *this* function. 3742 for (Value *V : CS.args()) 3743 if (auto *MD = dyn_cast<MetadataAsValue>(V)) 3744 visitMetadataAsValue(*MD, CS.getCaller()); 3745 3746 switch (ID) { 3747 default: 3748 break; 3749 case Intrinsic::ctlz: // llvm.ctlz 3750 case Intrinsic::cttz: // llvm.cttz 3751 Assert(isa<ConstantInt>(CS.getArgOperand(1)), 3752 "is_zero_undef argument of bit counting intrinsics must be a " 3753 "constant int", 3754 CS); 3755 break; 3756 case Intrinsic::dbg_declare: // llvm.dbg.declare 3757 Assert(isa<MetadataAsValue>(CS.getArgOperand(0)), 3758 "invalid llvm.dbg.declare intrinsic call 1", CS); 3759 visitDbgIntrinsic("declare", cast<DbgDeclareInst>(*CS.getInstruction())); 3760 break; 3761 case Intrinsic::dbg_value: // llvm.dbg.value 3762 visitDbgIntrinsic("value", cast<DbgValueInst>(*CS.getInstruction())); 3763 break; 3764 case Intrinsic::memcpy: 3765 case Intrinsic::memmove: 3766 case Intrinsic::memset: { 3767 ConstantInt *AlignCI = dyn_cast<ConstantInt>(CS.getArgOperand(3)); 3768 Assert(AlignCI, 3769 "alignment argument of memory intrinsics must be a constant int", 3770 CS); 3771 const APInt &AlignVal = AlignCI->getValue(); 3772 Assert(AlignCI->isZero() || AlignVal.isPowerOf2(), 3773 "alignment argument of memory intrinsics must be a power of 2", CS); 3774 Assert(isa<ConstantInt>(CS.getArgOperand(4)), 3775 "isvolatile argument of memory intrinsics must be a constant int", 3776 CS); 3777 break; 3778 } 3779 case Intrinsic::gcroot: 3780 case Intrinsic::gcwrite: 3781 case Intrinsic::gcread: 3782 if (ID == Intrinsic::gcroot) { 3783 AllocaInst *AI = 3784 dyn_cast<AllocaInst>(CS.getArgOperand(0)->stripPointerCasts()); 3785 Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", CS); 3786 Assert(isa<Constant>(CS.getArgOperand(1)), 3787 "llvm.gcroot parameter #2 must be a constant.", CS); 3788 if (!AI->getAllocatedType()->isPointerTy()) { 3789 Assert(!isa<ConstantPointerNull>(CS.getArgOperand(1)), 3790 "llvm.gcroot parameter #1 must either be a pointer alloca, " 3791 "or argument #2 must be a non-null constant.", 3792 CS); 3793 } 3794 } 3795 3796 Assert(CS.getParent()->getParent()->hasGC(), 3797 "Enclosing function does not use GC.", CS); 3798 break; 3799 case Intrinsic::init_trampoline: 3800 Assert(isa<Function>(CS.getArgOperand(1)->stripPointerCasts()), 3801 "llvm.init_trampoline parameter #2 must resolve to a function.", 3802 CS); 3803 break; 3804 case Intrinsic::prefetch: 3805 Assert(isa<ConstantInt>(CS.getArgOperand(1)) && 3806 isa<ConstantInt>(CS.getArgOperand(2)) && 3807 cast<ConstantInt>(CS.getArgOperand(1))->getZExtValue() < 2 && 3808 cast<ConstantInt>(CS.getArgOperand(2))->getZExtValue() < 4, 3809 "invalid arguments to llvm.prefetch", CS); 3810 break; 3811 case Intrinsic::stackprotector: 3812 Assert(isa<AllocaInst>(CS.getArgOperand(1)->stripPointerCasts()), 3813 "llvm.stackprotector parameter #2 must resolve to an alloca.", CS); 3814 break; 3815 case Intrinsic::lifetime_start: 3816 case Intrinsic::lifetime_end: 3817 case Intrinsic::invariant_start: 3818 Assert(isa<ConstantInt>(CS.getArgOperand(0)), 3819 "size argument of memory use markers must be a constant integer", 3820 CS); 3821 break; 3822 case Intrinsic::invariant_end: 3823 Assert(isa<ConstantInt>(CS.getArgOperand(1)), 3824 "llvm.invariant.end parameter #2 must be a constant integer", CS); 3825 break; 3826 3827 case Intrinsic::localescape: { 3828 BasicBlock *BB = CS.getParent(); 3829 Assert(BB == &BB->getParent()->front(), 3830 "llvm.localescape used outside of entry block", CS); 3831 Assert(!SawFrameEscape, 3832 "multiple calls to llvm.localescape in one function", CS); 3833 for (Value *Arg : CS.args()) { 3834 if (isa<ConstantPointerNull>(Arg)) 3835 continue; // Null values are allowed as placeholders. 3836 auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts()); 3837 Assert(AI && AI->isStaticAlloca(), 3838 "llvm.localescape only accepts static allocas", CS); 3839 } 3840 FrameEscapeInfo[BB->getParent()].first = CS.getNumArgOperands(); 3841 SawFrameEscape = true; 3842 break; 3843 } 3844 case Intrinsic::localrecover: { 3845 Value *FnArg = CS.getArgOperand(0)->stripPointerCasts(); 3846 Function *Fn = dyn_cast<Function>(FnArg); 3847 Assert(Fn && !Fn->isDeclaration(), 3848 "llvm.localrecover first " 3849 "argument must be function defined in this module", 3850 CS); 3851 auto *IdxArg = dyn_cast<ConstantInt>(CS.getArgOperand(2)); 3852 Assert(IdxArg, "idx argument of llvm.localrecover must be a constant int", 3853 CS); 3854 auto &Entry = FrameEscapeInfo[Fn]; 3855 Entry.second = unsigned( 3856 std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1)); 3857 break; 3858 } 3859 3860 case Intrinsic::experimental_gc_statepoint: 3861 Assert(!CS.isInlineAsm(), 3862 "gc.statepoint support for inline assembly unimplemented", CS); 3863 Assert(CS.getParent()->getParent()->hasGC(), 3864 "Enclosing function does not use GC.", CS); 3865 3866 VerifyStatepoint(CS); 3867 break; 3868 case Intrinsic::experimental_gc_result: { 3869 Assert(CS.getParent()->getParent()->hasGC(), 3870 "Enclosing function does not use GC.", CS); 3871 // Are we tied to a statepoint properly? 3872 CallSite StatepointCS(CS.getArgOperand(0)); 3873 const Function *StatepointFn = 3874 StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr; 3875 Assert(StatepointFn && StatepointFn->isDeclaration() && 3876 StatepointFn->getIntrinsicID() == 3877 Intrinsic::experimental_gc_statepoint, 3878 "gc.result operand #1 must be from a statepoint", CS, 3879 CS.getArgOperand(0)); 3880 3881 // Assert that result type matches wrapped callee. 3882 const Value *Target = StatepointCS.getArgument(2); 3883 auto *PT = cast<PointerType>(Target->getType()); 3884 auto *TargetFuncType = cast<FunctionType>(PT->getElementType()); 3885 Assert(CS.getType() == TargetFuncType->getReturnType(), 3886 "gc.result result type does not match wrapped callee", CS); 3887 break; 3888 } 3889 case Intrinsic::experimental_gc_relocate: { 3890 Assert(CS.getNumArgOperands() == 3, "wrong number of arguments", CS); 3891 3892 Assert(isa<PointerType>(CS.getType()->getScalarType()), 3893 "gc.relocate must return a pointer or a vector of pointers", CS); 3894 3895 // Check that this relocate is correctly tied to the statepoint 3896 3897 // This is case for relocate on the unwinding path of an invoke statepoint 3898 if (LandingPadInst *LandingPad = 3899 dyn_cast<LandingPadInst>(CS.getArgOperand(0))) { 3900 3901 const BasicBlock *InvokeBB = 3902 LandingPad->getParent()->getUniquePredecessor(); 3903 3904 // Landingpad relocates should have only one predecessor with invoke 3905 // statepoint terminator 3906 Assert(InvokeBB, "safepoints should have unique landingpads", 3907 LandingPad->getParent()); 3908 Assert(InvokeBB->getTerminator(), "safepoint block should be well formed", 3909 InvokeBB); 3910 Assert(isStatepoint(InvokeBB->getTerminator()), 3911 "gc relocate should be linked to a statepoint", InvokeBB); 3912 } 3913 else { 3914 // In all other cases relocate should be tied to the statepoint directly. 3915 // This covers relocates on a normal return path of invoke statepoint and 3916 // relocates of a call statepoint 3917 auto Token = CS.getArgOperand(0); 3918 Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)), 3919 "gc relocate is incorrectly tied to the statepoint", CS, Token); 3920 } 3921 3922 // Verify rest of the relocate arguments 3923 3924 ImmutableCallSite StatepointCS( 3925 cast<GCRelocateInst>(*CS.getInstruction()).getStatepoint()); 3926 3927 // Both the base and derived must be piped through the safepoint 3928 Value* Base = CS.getArgOperand(1); 3929 Assert(isa<ConstantInt>(Base), 3930 "gc.relocate operand #2 must be integer offset", CS); 3931 3932 Value* Derived = CS.getArgOperand(2); 3933 Assert(isa<ConstantInt>(Derived), 3934 "gc.relocate operand #3 must be integer offset", CS); 3935 3936 const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue(); 3937 const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue(); 3938 // Check the bounds 3939 Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(), 3940 "gc.relocate: statepoint base index out of bounds", CS); 3941 Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(), 3942 "gc.relocate: statepoint derived index out of bounds", CS); 3943 3944 // Check that BaseIndex and DerivedIndex fall within the 'gc parameters' 3945 // section of the statepoint's argument 3946 Assert(StatepointCS.arg_size() > 0, 3947 "gc.statepoint: insufficient arguments"); 3948 Assert(isa<ConstantInt>(StatepointCS.getArgument(3)), 3949 "gc.statement: number of call arguments must be constant integer"); 3950 const unsigned NumCallArgs = 3951 cast<ConstantInt>(StatepointCS.getArgument(3))->getZExtValue(); 3952 Assert(StatepointCS.arg_size() > NumCallArgs + 5, 3953 "gc.statepoint: mismatch in number of call arguments"); 3954 Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5)), 3955 "gc.statepoint: number of transition arguments must be " 3956 "a constant integer"); 3957 const int NumTransitionArgs = 3958 cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5)) 3959 ->getZExtValue(); 3960 const int DeoptArgsStart = 4 + NumCallArgs + 1 + NumTransitionArgs + 1; 3961 Assert(isa<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart)), 3962 "gc.statepoint: number of deoptimization arguments must be " 3963 "a constant integer"); 3964 const int NumDeoptArgs = 3965 cast<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart))->getZExtValue(); 3966 const int GCParamArgsStart = DeoptArgsStart + 1 + NumDeoptArgs; 3967 const int GCParamArgsEnd = StatepointCS.arg_size(); 3968 Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd, 3969 "gc.relocate: statepoint base index doesn't fall within the " 3970 "'gc parameters' section of the statepoint call", 3971 CS); 3972 Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd, 3973 "gc.relocate: statepoint derived index doesn't fall within the " 3974 "'gc parameters' section of the statepoint call", 3975 CS); 3976 3977 // Relocated value must be either a pointer type or vector-of-pointer type, 3978 // but gc_relocate does not need to return the same pointer type as the 3979 // relocated pointer. It can be casted to the correct type later if it's 3980 // desired. However, they must have the same address space and 'vectorness' 3981 GCRelocateInst &Relocate = cast<GCRelocateInst>(*CS.getInstruction()); 3982 Assert(Relocate.getDerivedPtr()->getType()->getScalarType()->isPointerTy(), 3983 "gc.relocate: relocated value must be a gc pointer", CS); 3984 3985 auto ResultType = CS.getType(); 3986 auto DerivedType = Relocate.getDerivedPtr()->getType(); 3987 Assert(ResultType->isVectorTy() == DerivedType->isVectorTy(), 3988 "gc.relocate: vector relocates to vector and pointer to pointer", CS); 3989 Assert(ResultType->getPointerAddressSpace() == 3990 DerivedType->getPointerAddressSpace(), 3991 "gc.relocate: relocating a pointer shouldn't change its address space", CS); 3992 break; 3993 } 3994 case Intrinsic::eh_exceptioncode: 3995 case Intrinsic::eh_exceptionpointer: { 3996 Assert(isa<CatchPadInst>(CS.getArgOperand(0)), 3997 "eh.exceptionpointer argument must be a catchpad", CS); 3998 break; 3999 } 4000 }; 4001} 4002 4003/// \brief Carefully grab the subprogram from a local scope. 4004/// 4005/// This carefully grabs the subprogram from a local scope, avoiding the 4006/// built-in assertions that would typically fire. 4007static DISubprogram *getSubprogram(Metadata *LocalScope) { 4008 if (!LocalScope) 4009 return nullptr; 4010 4011 if (auto *SP = dyn_cast<DISubprogram>(LocalScope)) 4012 return SP; 4013 4014 if (auto *LB = dyn_cast<DILexicalBlockBase>(LocalScope)) 4015 return getSubprogram(LB->getRawScope()); 4016 4017 // Just return null; broken scope chains are checked elsewhere. 4018 assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope"); 4019 return nullptr; 4020} 4021 4022template <class DbgIntrinsicTy> 4023void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) { 4024 auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata(); 4025 Assert(isa<ValueAsMetadata>(MD) || 4026 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()), 4027 "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD); 4028 Assert(isa<DILocalVariable>(DII.getRawVariable()), 4029 "invalid llvm.dbg." + Kind + " intrinsic variable", &DII, 4030 DII.getRawVariable()); 4031 Assert(isa<DIExpression>(DII.getRawExpression()), 4032 "invalid llvm.dbg." + Kind + " intrinsic expression", &DII, 4033 DII.getRawExpression()); 4034 4035 // Ignore broken !dbg attachments; they're checked elsewhere. 4036 if (MDNode *N = DII.getDebugLoc().getAsMDNode()) 4037 if (!isa<DILocation>(N)) 4038 return; 4039 4040 BasicBlock *BB = DII.getParent(); 4041 Function *F = BB ? BB->getParent() : nullptr; 4042 4043 // The scopes for variables and !dbg attachments must agree. 4044 DILocalVariable *Var = DII.getVariable(); 4045 DILocation *Loc = DII.getDebugLoc(); 4046 Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment", 4047 &DII, BB, F); 4048 4049 DISubprogram *VarSP = getSubprogram(Var->getRawScope()); 4050 DISubprogram *LocSP = getSubprogram(Loc->getRawScope()); 4051 if (!VarSP || !LocSP) 4052 return; // Broken scope chains are checked elsewhere. 4053 4054 Assert(VarSP == LocSP, "mismatched subprogram between llvm.dbg." + Kind + 4055 " variable and !dbg attachment", 4056 &DII, BB, F, Var, Var->getScope()->getSubprogram(), Loc, 4057 Loc->getScope()->getSubprogram()); 4058} 4059 4060template <class MapTy> 4061static uint64_t getVariableSize(const DILocalVariable &V, const MapTy &Map) { 4062 // Be careful of broken types (checked elsewhere). 4063 const Metadata *RawType = V.getRawType(); 4064 while (RawType) { 4065 // Try to get the size directly. 4066 if (auto *T = dyn_cast<DIType>(RawType)) 4067 if (uint64_t Size = T->getSizeInBits()) 4068 return Size; 4069 4070 if (auto *DT = dyn_cast<DIDerivedType>(RawType)) { 4071 // Look at the base type. 4072 RawType = DT->getRawBaseType(); 4073 continue; 4074 } 4075 4076 if (auto *S = dyn_cast<MDString>(RawType)) { 4077 // Don't error on missing types (checked elsewhere). 4078 RawType = Map.lookup(S); 4079 continue; 4080 } 4081 4082 // Missing type or size. 4083 break; 4084 } 4085 4086 // Fail gracefully. 4087 return 0; 4088} 4089 4090template <class MapTy> 4091void Verifier::verifyBitPieceExpression(const DbgInfoIntrinsic &I, 4092 const MapTy &TypeRefs) { 4093 DILocalVariable *V; 4094 DIExpression *E; 4095 if (auto *DVI = dyn_cast<DbgValueInst>(&I)) { 4096 V = dyn_cast_or_null<DILocalVariable>(DVI->getRawVariable()); 4097 E = dyn_cast_or_null<DIExpression>(DVI->getRawExpression()); 4098 } else { 4099 auto *DDI = cast<DbgDeclareInst>(&I); 4100 V = dyn_cast_or_null<DILocalVariable>(DDI->getRawVariable()); 4101 E = dyn_cast_or_null<DIExpression>(DDI->getRawExpression()); 4102 } 4103 4104 // We don't know whether this intrinsic verified correctly. 4105 if (!V || !E || !E->isValid()) 4106 return; 4107 4108 // Nothing to do if this isn't a bit piece expression. 4109 if (!E->isBitPiece()) 4110 return; 4111 4112 // The frontend helps out GDB by emitting the members of local anonymous 4113 // unions as artificial local variables with shared storage. When SROA splits 4114 // the storage for artificial local variables that are smaller than the entire 4115 // union, the overhang piece will be outside of the allotted space for the 4116 // variable and this check fails. 4117 // FIXME: Remove this check as soon as clang stops doing this; it hides bugs. 4118 if (V->isArtificial()) 4119 return; 4120 4121 // If there's no size, the type is broken, but that should be checked 4122 // elsewhere. 4123 uint64_t VarSize = getVariableSize(*V, TypeRefs); 4124 if (!VarSize) 4125 return; 4126 4127 unsigned PieceSize = E->getBitPieceSize(); 4128 unsigned PieceOffset = E->getBitPieceOffset(); 4129 Assert(PieceSize + PieceOffset <= VarSize, 4130 "piece is larger than or outside of variable", &I, V, E); 4131 Assert(PieceSize != VarSize, "piece covers entire variable", &I, V, E); 4132} 4133 4134void Verifier::visitUnresolvedTypeRef(const MDString *S, const MDNode *N) { 4135 // This is in its own function so we get an error for each bad type ref (not 4136 // just the first). 4137 Assert(false, "unresolved type ref", S, N); 4138} 4139 4140void Verifier::verifyTypeRefs() { 4141 auto *CUs = M->getNamedMetadata("llvm.dbg.cu"); 4142 if (!CUs) 4143 return; 4144 4145 // Visit all the compile units again to map the type references. 4146 SmallDenseMap<const MDString *, const DIType *, 32> TypeRefs; 4147 for (auto *CU : CUs->operands()) 4148 if (auto Ts = cast<DICompileUnit>(CU)->getRetainedTypes()) 4149 for (DIType *Op : Ts) 4150 if (auto *T = dyn_cast_or_null<DICompositeType>(Op)) 4151 if (auto *S = T->getRawIdentifier()) { 4152 UnresolvedTypeRefs.erase(S); 4153 TypeRefs.insert(std::make_pair(S, T)); 4154 } 4155 4156 // Verify debug info intrinsic bit piece expressions. This needs a second 4157 // pass through the intructions, since we haven't built TypeRefs yet when 4158 // verifying functions, and simply queuing the DbgInfoIntrinsics to evaluate 4159 // later/now would queue up some that could be later deleted. 4160 for (const Function &F : *M) 4161 for (const BasicBlock &BB : F) 4162 for (const Instruction &I : BB) 4163 if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I)) 4164 verifyBitPieceExpression(*DII, TypeRefs); 4165 4166 // Return early if all typerefs were resolved. 4167 if (UnresolvedTypeRefs.empty()) 4168 return; 4169 4170 // Sort the unresolved references by name so the output is deterministic. 4171 typedef std::pair<const MDString *, const MDNode *> TypeRef; 4172 SmallVector<TypeRef, 32> Unresolved(UnresolvedTypeRefs.begin(), 4173 UnresolvedTypeRefs.end()); 4174 std::sort(Unresolved.begin(), Unresolved.end(), 4175 [](const TypeRef &LHS, const TypeRef &RHS) { 4176 return LHS.first->getString() < RHS.first->getString(); 4177 }); 4178 4179 // Visit the unresolved refs (printing out the errors). 4180 for (const TypeRef &TR : Unresolved) 4181 visitUnresolvedTypeRef(TR.first, TR.second); 4182} 4183 4184//===----------------------------------------------------------------------===// 4185// Implement the public interfaces to this file... 4186//===----------------------------------------------------------------------===// 4187 4188bool llvm::verifyFunction(const Function &f, raw_ostream *OS) { 4189 Function &F = const_cast<Function &>(f); 4190 assert(!F.isDeclaration() && "Cannot verify external functions"); 4191 4192 raw_null_ostream NullStr; 4193 Verifier V(OS ? *OS : NullStr); 4194 4195 // Note that this function's return value is inverted from what you would 4196 // expect of a function called "verify". 4197 return !V.verify(F); 4198} 4199 4200bool llvm::verifyModule(const Module &M, raw_ostream *OS) { 4201 raw_null_ostream NullStr; 4202 Verifier V(OS ? *OS : NullStr); 4203 4204 bool Broken = false; 4205 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) 4206 if (!I->isDeclaration() && !I->isMaterializable()) 4207 Broken |= !V.verify(*I); 4208 4209 // Note that this function's return value is inverted from what you would 4210 // expect of a function called "verify". 4211 return !V.verify(M) || Broken; 4212} 4213 4214namespace { 4215struct VerifierLegacyPass : public FunctionPass { 4216 static char ID; 4217 4218 Verifier V; 4219 bool FatalErrors; 4220 4221 VerifierLegacyPass() : FunctionPass(ID), V(dbgs()), FatalErrors(true) { 4222 initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry()); 4223 } 4224 explicit VerifierLegacyPass(bool FatalErrors) 4225 : FunctionPass(ID), V(dbgs()), FatalErrors(FatalErrors) { 4226 initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry()); 4227 } 4228 4229 bool runOnFunction(Function &F) override { 4230 if (!V.verify(F) && FatalErrors) 4231 report_fatal_error("Broken function found, compilation aborted!"); 4232 4233 return false; 4234 } 4235 4236 bool doFinalization(Module &M) override { 4237 if (!V.verify(M) && FatalErrors) 4238 report_fatal_error("Broken module found, compilation aborted!"); 4239 4240 return false; 4241 } 4242 4243 void getAnalysisUsage(AnalysisUsage &AU) const override { 4244 AU.setPreservesAll(); 4245 } 4246}; 4247} 4248 4249char VerifierLegacyPass::ID = 0; 4250INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false) 4251 4252FunctionPass *llvm::createVerifierPass(bool FatalErrors) { 4253 return new VerifierLegacyPass(FatalErrors); 4254} 4255 4256PreservedAnalyses VerifierPass::run(Module &M) { 4257 if (verifyModule(M, &dbgs()) && FatalErrors) 4258 report_fatal_error("Broken module found, compilation aborted!"); 4259 4260 return PreservedAnalyses::all(); 4261} 4262 4263PreservedAnalyses VerifierPass::run(Function &F) { 4264 if (verifyFunction(F, &dbgs()) && FatalErrors) 4265 report_fatal_error("Broken function found, compilation aborted!"); 4266 4267 return PreservedAnalyses::all(); 4268} 4269