Verifier.cpp revision fe45fd084db872f9c7106c26e52c1cc8c9cba3a5
1f2038fb01417bcf7698b87a5dfaa4a861539618aerik.corry@gmail.com//===-- Verifier.cpp - Implement the Module Verifier -----------------------==// 23484964a86451e86dcf04be9bd8c0d76ee04f081rossberg@chromium.org// 33484964a86451e86dcf04be9bd8c0d76ee04f081rossberg@chromium.org// The LLVM Compiler Infrastructure 4a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// 5a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// This file is distributed under the University of Illinois Open Source 6a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// License. See LICENSE.TXT for details. 7a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// 8196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org//===----------------------------------------------------------------------===// 9196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// 10196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// This file defines the function verifier interface, that can be used for some 11196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// sanity checking of input to the system. 12196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// 13196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// Note that this does not provide full `Java style' security and verifications, 14196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// instead it just tries to ensure that code is well-formed. 159d1a7a8cdb664730cf5703185e85a4716748c564machenbach@chromium.org// 16196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// * Both of a binary operator's parameters are of the same type 17f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org// * Verify that the indices of mem access instructions match other operands 18196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// * Verify that arithmetic and other things are only performed on first-class 19196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// types. Verify that shifts & logicals only happen on integrals f.e. 20196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// * All of the constants in a switch statement are of the correct type 21196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org// * The code is in valid SSA form 22a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * It should be illegal to put a label into any other type (like a structure) 23a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// or to return one. [except constant arrays!] 24a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad 25a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * PHI nodes must have an entry for each predecessor, with no extras. 26a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * PHI nodes must be the first thing in a basic block, all grouped together 27f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org// * PHI nodes must have at least one entry 28a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * All basic blocks should only end with terminator insts, not contain them 29af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org// * The entry node to a function must not have predecessors 30a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * All Instructions must be embedded into a basic block 311510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org// * Functions cannot take a void-typed parameter 32a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * Verify that a function's argument list agrees with it's declared type. 33a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * It is illegal to specify a name for a void value. 34cc8e177451e2ab80cf4eacfd782d19cd05ec2070hpayer@chromium.org// * It is illegal to have a internal global value with no initializer 35a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * It is illegal to have a ret instruction that returns a value that does not 36a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// agree with the function return value type. 37a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * Function call argument types match the function prototype 38a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * A landing pad is defined by a landingpad instruction, and can be jumped to 39dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org// only by the unwind edge of an invoke instruction. 40837a67edd9afdbfe1b59482b41693f59c48846ffulan@chromium.org// * A landingpad instruction must be the first non-PHI instruction in the 4133e09c8efd078308de3c77a88301566f65c07befverwaest@chromium.org// block. 42a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * All landingpad instructions must use the same personality function with 43a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// the same function. 44a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// * All other things that are tested by asserts spread about the code... 45a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// 46a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org//===----------------------------------------------------------------------===// 47a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 48c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org#include "llvm/Analysis/Verifier.h" 49a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/ADT/STLExtras.h" 50a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/ADT/SetVector.h" 511e2d50cf3d94ff48285da107b7a9da1ad0fc873dmachenbach@chromium.org#include "llvm/ADT/SmallPtrSet.h" 5294b0d6fcb08a2f01ba52c6edb712068f482366f1danno@chromium.org#include "llvm/ADT/SmallVector.h" 53a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/ADT/StringExtras.h" 54a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/Analysis/Dominators.h" 55a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/Assembly/Writer.h" 56a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/DebugInfo.h" 57c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org#include "llvm/IR/CallingConv.h" 58a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/IR/Constants.h" 59a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/IR/DataLayout.h" 60876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#include "llvm/IR/DerivedTypes.h" 614f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org#include "llvm/IR/InlineAsm.h" 6226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org#include "llvm/IR/IntrinsicInst.h" 6326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org#include "llvm/IR/LLVMContext.h" 64a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/IR/Metadata.h" 65a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/IR/Module.h" 664a9f6553038df6b893b3d3ccae351723f4cbbae7yangguo@chromium.org#include "llvm/InstVisitor.h" 67a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/Pass.h" 68a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/PassManager.h" 69594006017e46d82ed7146611dc12c20e3c509c7ddanno@chromium.org#include "llvm/Support/CFG.h" 70a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/Support/CallSite.h" 711510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org#include "llvm/Support/CommandLine.h" 72a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org#include "llvm/Support/ConstantRange.h" 731456e708d277e725ca42a03463af16fe471c9210jkummerow@chromium.org#include "llvm/Support/Debug.h" 74c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org#include "llvm/Support/ErrorHandling.h" 75c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org#include "llvm/Support/raw_ostream.h" 761f410f9a9c4fbd4270749af64b477df87b753158mstarzinger@chromium.org#include <algorithm> 77c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org#include <cstdarg> 784f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.orgusing namespace llvm; 79e0e1b0d3e70c933d36ed381d511e9fda39f2a751mstarzinger@chromium.org 80c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.orgstatic cl::opt<bool> DisableDebugInfoVerifier("disable-debug-info-verifier", 814f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org cl::init(true)); 820cc095007a3ccded63f6577751c6a04300eb7ae9machenbach@chromium.org 834f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.orgnamespace { // Anonymous namespace for class 840a4e901cdfb5505a896d30aa8c2e04fce0fbe069vegorov@chromium.org struct PreVerifier : public FunctionPass { 85a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org static char ID; // Pass ID, replacement for typeid 86ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 8783aa54905e559090bea7771b83f188762cfcf082ricow@chromium.org PreVerifier() : FunctionPass(ID) { 88c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org initializePreVerifierPass(*PassRegistry::getPassRegistry()); 894e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org } 9056454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org 91a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org virtual void getAnalysisUsage(AnalysisUsage &AU) const { 92a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org AU.setPreservesAll(); 93ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } 9446a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org 95a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Check that the prerequisites for successful DominatorTree construction 96d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org // are satisfied. 97c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org bool runOnFunction(Function &F) { 98c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org bool Broken = false; 99c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org 100a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) { 10149edbdf52640c88918f8e6638ab4965819eb1dfekmillikin@chromium.org if (I->empty() || !I->back().isTerminator()) { 102a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org dbgs() << "Basic Block in function '" << F.getName() 1034f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org << "' does not have terminator!\n"; 1044f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org WriteAsOperand(dbgs(), I, true); 1052bda543d75374afd8d7e98f56ca99a57ae1b7bd1svenpanne@chromium.org dbgs() << "\n"; 106a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Broken = true; 107d2c22f0121ebc55ee26a9e742f0fd7c0b8397730kmillikin@chromium.org } 108160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org } 1094f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org 1104f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org if (Broken) 1110ad885c06ff6a0d68bc9ad75629f7ddfaa6860b9erikcorry report_fatal_error("Broken module, no Basic Block terminator!"); 1124f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org 1134f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org return false; 114a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 115c6c5718277d4047fad1e034396228ce15571b5a4sgjesse@chromium.org }; 116c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org} 117378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org 118c36ce6e8979bbbd43539f0a0effc87ea20dd65cckmillikin@chromium.orgchar PreVerifier::ID = 0; 119c36ce6e8979bbbd43539f0a0effc87ea20dd65cckmillikin@chromium.orgINITIALIZE_PASS(PreVerifier, "preverify", "Preliminary module verification", 120e4ee6de0de64744d55b63da83156827c989c7099verwaest@chromium.org false, false) 121a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgstatic char &PreVerifyID = PreVerifier::ID; 122a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 123a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgnamespace { 124528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org struct Verifier : public FunctionPass, public InstVisitor<Verifier> { 125355cfd19c23ac613f2738a40e356ea48297f7d5eyangguo@chromium.org static char ID; // Pass ID, replacement for typeid 126efdb9d70bddd496ceb6a281dadcc065efbce37a1yangguo@chromium.org bool Broken; // Is this module found to be broken? 127471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org VerifierFailureAction action; 128a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // What to do if verification fails. 129a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Module *Mod; // Module we are verifying right now 130a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org LLVMContext *Context; // Context within which we are verifying 131a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org DominatorTree *DT; // Dominator Tree, caution can be null! 1325f0c45f2cacb31d36a8f80c31f17bda7751a3644ager@chromium.org const DataLayout *DL; 133011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org 134a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org std::string Messages; 135a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org raw_string_ostream MessagesStr; 136e4ee6de0de64744d55b63da83156827c989c7099verwaest@chromium.org 137a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org /// InstInThisBlock - when verifying a basic block, keep track of all of the 138e8412be858dc48afaec4959e42c5932f71a7f29bmachenbach@chromium.org /// instructions we have seen so far. This allows us to do efficient 13932280cf2786219b2d9a668f7f00778fb59ac40b3mstarzinger@chromium.org /// dominance checks for the case when an instruction has an operand that is 140a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org /// an instruction in the same block. 141a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org SmallPtrSet<Instruction*, 16> InstsInThisBlock; 142a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 143a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org /// MDNodes - keep track of the metadata nodes that have been checked 144662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org /// already. 14583aa54905e559090bea7771b83f188762cfcf082ricow@chromium.org SmallPtrSet<MDNode *, 32> MDNodes; 1461e2d50cf3d94ff48285da107b7a9da1ad0fc873dmachenbach@chromium.org 14774f333bce721daf6b1f9d7d3d3faa623f77658d7vegorov@chromium.org /// PersonalityFn - The personality function referenced by the 148e4ee6de0de64744d55b63da83156827c989c7099verwaest@chromium.org /// LandingPadInsts. All LandingPadInsts within the same function must use 149a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org /// the same personality function. 150a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org const Value *PersonalityFn; 151a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 152160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org /// Finder keeps track of all debug info MDNodes in a Module. 1530a4e901cdfb5505a896d30aa8c2e04fce0fbe069vegorov@chromium.org DebugInfoFinder Finder; 154b08986cb66c3f6687247cb6da186c1e73057e399whesse@chromium.org 155471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org Verifier() 156a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org : FunctionPass(ID), Broken(false), 157d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org action(AbortProcessAction), Mod(0), Context(0), DT(0), DL(0), 158ea88ce93dcb41a9200ec8747ae7642a5db1f4ce7sgjesse@chromium.org MessagesStr(Messages), PersonalityFn(0) { 159394dbcf9009cf5203b6d85e8b515fcff072040f3erik.corry@gmail.com initializeVerifierPass(*PassRegistry::getPassRegistry()); 16094b0d6fcb08a2f01ba52c6edb712068f482366f1danno@chromium.org } 161a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org explicit Verifier(VerifierFailureAction ctn) 1624f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org : FunctionPass(ID), Broken(false), action(ctn), Mod(0), 163a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Context(0), DT(0), DL(0), MessagesStr(Messages), PersonalityFn(0) { 164a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org initializeVerifierPass(*PassRegistry::getPassRegistry()); 165d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org } 166154ff99473e866f5eb00a44045e27866a7fdce29yangguo@chromium.org 167a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org bool doInitialization(Module &M) { 16828faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org Mod = &M; 16928faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org Context = &M.getContext(); 17028faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org 17128faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org DL = getAnalysisIfAvailable<DataLayout>(); 172c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org 173c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org // We must abort before returning back to the pass manager, or else the 174d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // pass manager may try to run other passes on the broken module. 175a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return abortIfBroken(); 176c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org } 177c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org 178c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org bool runOnFunction(Function &F) { 17957ff881caeb2e15b46ac9e4dfc00e378f7c5f929ulan@chromium.org // Get dominator information if we are being run by PassManager 180c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org DT = &getAnalysis<DominatorTree>(); 18178d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org 182a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Mod = F.getParent(); 183c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org if (!Context) Context = &F.getContext(); 184c8e8806f9e54a027d667425f1bb1b28cf9cbb6f7machenbach@chromium.org 185c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org Finder.reset(); 186e8412be858dc48afaec4959e42c5932f71a7f29bmachenbach@chromium.org visit(F); 1875c88bc39690cc94affe78cf5777eb8180c4af8a4machenbach@chromium.org InstsInThisBlock.clear(); 1885c88bc39690cc94affe78cf5777eb8180c4af8a4machenbach@chromium.org PersonalityFn = 0; 189c73d55b355913690124f3ee70c344035431cdd3ayangguo@chromium.org 190a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!DisableDebugInfoVerifier) 19132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Verify Debug Info. 19232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org verifyDebugInfo(); 19332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 19432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // We must abort before returning back to the pass manager, or else the 19532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // pass manager may try to run other passes on the broken module. 196dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org return abortIfBroken(); 197a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 198a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 19932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org bool doFinalization(Module &M) { 20032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Scan through, checking all of the external function's linkage now... 20132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { 20232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org visitGlobalValue(*I); 20332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 20432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Check to make sure function prototypes are okay. 20532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org if (I->isDeclaration()) visitFunction(*I); 20632cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org } 20732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 20832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org for (Module::global_iterator I = M.global_begin(), E = M.global_end(); 209a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I != E; ++I) 210a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitGlobalVariable(*I); 211f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 212f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); 213f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org I != E; ++I) 21432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org visitGlobalAlias(*I); 215a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2168f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org for (Module::named_metadata_iterator I = M.named_metadata_begin(), 2178f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org E = M.named_metadata_end(); I != E; ++I) 2188f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org visitNamedMDNode(*I); 2198f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org 2208f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org visitModuleFlags(M); 221a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitModuleIdents(M); 222a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2238f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org if (!DisableDebugInfoVerifier) { 2248f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org Finder.reset(); 2258f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org Finder.processModule(M); 2268f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org // Verify Debug Info. 227a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org verifyDebugInfo(); 228a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 229a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 230a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // If the module is broken, abort at this time. 231812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org return abortIfBroken(); 232812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org } 233812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org 234812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org virtual void getAnalysisUsage(AnalysisUsage &AU) const { 235812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org AU.setPreservesAll(); 236812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org AU.addRequiredID(PreVerifyID); 237812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org AU.addRequired<DominatorTree>(); 238812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org } 239ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org 240ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org /// abortIfBroken - If the module is broken and we are supposed to abort on 241ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org /// this condition, do so. 242a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org /// 243a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org bool abortIfBroken() { 244a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!Broken) return false; 245a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org MessagesStr << "Broken module found, "; 246a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org switch (action) { 247b99c75496e05b4cd58815ada1e39e6029130d11crossberg@chromium.org case AbortProcessAction: 2488f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org MessagesStr << "compilation aborted!\n"; 249ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org dbgs() << MessagesStr.str(); 250ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org // Client should choose different reaction if abort is not desired 251ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org abort(); 2528f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org case PrintMessageAction: 2538f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org MessagesStr << "verification continues.\n"; 254a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org dbgs() << MessagesStr.str(); 2551fd77d58ca66b2711f09cdea32c0c2d1a01b3ae5danno@chromium.org return false; 2561fd77d58ca66b2711f09cdea32c0c2d1a01b3ae5danno@chromium.org case ReturnStatusAction: 2571fd77d58ca66b2711f09cdea32c0c2d1a01b3ae5danno@chromium.org MessagesStr << "compilation terminated.\n"; 2581fd77d58ca66b2711f09cdea32c0c2d1a01b3ae5danno@chromium.org return true; 2598f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org } 260c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org llvm_unreachable("Invalid action"); 2618f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org } 262c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org 2635f0c45f2cacb31d36a8f80c31f17bda7751a3644ager@chromium.org 264a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Verification methods... 265a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitGlobalValue(GlobalValue &GV); 266a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitGlobalVariable(GlobalVariable &GV); 267a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitGlobalAlias(GlobalAlias &GA); 268a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitNamedMDNode(NamedMDNode &NMD); 2698f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org void visitMDNode(MDNode &MD, Function *F); 2708f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org void visitModuleIdents(Module &M); 271471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org void visitModuleFlags(Module &M); 272471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org void visitModuleFlag(MDNode *Op, DenseMap<MDString*, MDNode*> &SeenIDs, 273a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org SmallVectorImpl<MDNode*> &Requirements); 2748f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org void visitFunction(Function &F); 2758f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org void visitBasicBlock(BasicBlock &BB); 2768f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org using InstVisitor<Verifier>::visit; 277fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org 278fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org void visit(Instruction &I); 279fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org 280a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitTruncInst(TruncInst &I); 281a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitZExtInst(ZExtInst &I); 282a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitSExtInst(SExtInst &I); 283a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitFPTruncInst(FPTruncInst &I); 284a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitFPExtInst(FPExtInst &I); 285a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitFPToUIInst(FPToUIInst &I); 286a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitFPToSIInst(FPToSIInst &I); 287a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitUIToFPInst(UIToFPInst &I); 288a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org void visitSIToFPInst(SIToFPInst &I); 2893847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitIntToPtrInst(IntToPtrInst &I); 2903847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitPtrToIntInst(PtrToIntInst &I); 2913847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitBitCastInst(BitCastInst &I); 2923847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitAddrSpaceCastInst(AddrSpaceCastInst &I); 2933847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitPHINode(PHINode &PN); 2943847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitBinaryOperator(BinaryOperator &B); 295ab30bb83bf3dae0053739c57b1db9ad13c1f9e3ayangguo@chromium.org void visitICmpInst(ICmpInst &IC); 2963847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitFCmpInst(FCmpInst &FC); 2973847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitExtractElementInst(ExtractElementInst &EI); 2983847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitInsertElementInst(InsertElementInst &EI); 2993847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitShuffleVectorInst(ShuffleVectorInst &EI); 3003847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); } 3013847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitCallInst(CallInst &CI); 3023847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitInvokeInst(InvokeInst &II); 3033847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitGetElementPtrInst(GetElementPtrInst &GEP); 3043847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitLoadInst(LoadInst &LI); 3053847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitStoreInst(StoreInst &SI); 3063847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void verifyDominatesUse(Instruction &I, unsigned i); 3073847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitInstruction(Instruction &I); 3083847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitTerminatorInst(TerminatorInst &I); 3093847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitBranchInst(BranchInst &BI); 3103847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitReturnInst(ReturnInst &RI); 3113847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitSwitchInst(SwitchInst &SI); 3123847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitIndirectBrInst(IndirectBrInst &BI); 3133847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitSelectInst(SelectInst &SI); 3143847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitUserOp1(Instruction &I); 3153847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitUserOp2(Instruction &I) { visitUserOp1(I); } 3163847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI); 3173847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI); 31832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org void visitAtomicRMWInst(AtomicRMWInst &RMWI); 3193847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitFenceInst(FenceInst &FI); 3203847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitAllocaInst(AllocaInst &AI); 3213847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitExtractValueInst(ExtractValueInst &EVI); 3223847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitInsertValueInst(InsertValueInst &IVI); 3233847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void visitLandingPadInst(LandingPadInst &LPI); 3243847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com 3253847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyCallSite(CallSite CS); 3263847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, 3273847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com int VT, unsigned ArgNo, std::string &Suffix); 3283847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool VerifyIntrinsicType(Type *Ty, 3293847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com ArrayRef<Intrinsic::IITDescriptor> &Infos, 3303847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com SmallVectorImpl<Type*> &ArgTys); 3313847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool VerifyIntrinsicIsVarArg(bool isVarArg, 3323847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com ArrayRef<Intrinsic::IITDescriptor> &Infos); 3333847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool VerifyAttributeCount(AttributeSet Attrs, unsigned Params); 3343847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, 3353847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool isFunction, const Value *V); 3363847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 3373847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com bool isReturnValue, const Value *V); 3383847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 3393847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com const Value *V); 3403847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com 3413847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyBitcastType(const Value *V, Type *DestTy, Type *SrcTy); 3423847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void VerifyConstantExprBitcastType(const ConstantExpr *CE); 3433847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com 3443847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com void verifyDebugInfo(); 345f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 34605ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org void WriteValue(const Value *V) { 34705ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org if (!V) return; 348f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (isa<Instruction>(V)) { 34928faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org MessagesStr << *V << '\n'; 35028faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org } else { 35105ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org WriteAsOperand(MessagesStr, V, true, Mod); 352f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org MessagesStr << '\n'; 353f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 354f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 35528faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org 356f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org void WriteType(Type *T) { 35705ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org if (!T) return; 35805ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org MessagesStr << ' ' << *T; 3597c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org } 360f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 361f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 362f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // CheckFailed - A check failed, so print out the condition and the message 363f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // that failed. This provides a nice place to put a breakpoint if you want 364f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // to see why something is not correct. 365f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org void CheckFailed(const Twine &Message, 366f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org const Value *V1 = 0, const Value *V2 = 0, 36732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org const Value *V3 = 0, const Value *V4 = 0) { 368876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org MessagesStr << Message.str() << "\n"; 369876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V1); 370876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V2); 371876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V3); 372876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V4); 373876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Broken = true; 374876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org } 375876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 376876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org void CheckFailed(const Twine &Message, const Value *V1, 377876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Type *T2, const Value *V3 = 0) { 378876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org MessagesStr << Message.str() << "\n"; 379876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V1); 380876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteType(T2); 381876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteValue(V3); 382876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Broken = true; 383876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org } 384876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 385876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org void CheckFailed(const Twine &Message, Type *T1, 386876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Type *T2 = 0, Type *T3 = 0) { 387876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org MessagesStr << Message.str() << "\n"; 388876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteType(T1); 389876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteType(T2); 390876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org WriteType(T3); 391876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Broken = true; 392876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org } 393876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org }; 394876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org} // End anonymous namespace 395876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 396876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.orgchar Verifier::ID = 0; 397876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.orgINITIALIZE_PASS_BEGIN(Verifier, "verify", "Module Verifier", false, false) 398876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.orgINITIALIZE_PASS_DEPENDENCY(PreVerifier) 399876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.orgINITIALIZE_PASS_DEPENDENCY(DominatorTree) 400876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.orgINITIALIZE_PASS_END(Verifier, "verify", "Module Verifier", false, false) 401876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 402876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org// Assert - We know that cond should be true, if not print an error message. 403876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#define Assert(C, M) \ 404876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org do { if (!(C)) { CheckFailed(M); return; } } while (0) 405876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#define Assert1(C, M, V1) \ 406876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org do { if (!(C)) { CheckFailed(M, V1); return; } } while (0) 407876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#define Assert2(C, M, V1, V2) \ 408876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0) 409876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#define Assert3(C, M, V1, V2, V3) \ 410876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org do { if (!(C)) { CheckFailed(M, V1, V2, V3); return; } } while (0) 411876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org#define Assert4(C, M, V1, V2, V3, V4) \ 412f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0) 413f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 414f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.orgvoid Verifier::visit(Instruction &I) { 415f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) 416f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(I.getOperand(i) != 0, "Operand is null", &I); 417f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org InstVisitor<Verifier>::visit(I); 418f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org} 419f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 420f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 421f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.orgvoid Verifier::visitGlobalValue(GlobalValue &GV) { 422f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!GV.isDeclaration() || 423f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GV.isMaterializable() || 424f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GV.hasExternalLinkage() || 425f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GV.hasDLLImportLinkage() || 426f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GV.hasExternalWeakLinkage() || 427f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org (isa<GlobalAlias>(GV) && 428f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org (GV.hasLocalLinkage() || GV.hasWeakLinkage())), 429f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Global is external, but doesn't have external or dllimport or weak linkage!", 430f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org &GV); 431f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 432f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!GV.hasDLLImportLinkage() || GV.isDeclaration(), 433f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Global is marked as dllimport, but not external", &GV); 434f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 435f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV), 436f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Only global variables can have appending linkage!", &GV); 437f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 438f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (GV.hasAppendingLinkage()) { 439f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV); 440f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(GVar && GVar->getType()->getElementType()->isArrayTy(), 441f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Only global arrays can have appending linkage!", GVar); 442f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 443f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org} 444f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 445f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.orgvoid Verifier::visitGlobalVariable(GlobalVariable &GV) { 446f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (GV.hasInitializer()) { 447f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(), 448f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Global variable initializer type does not match global " 449f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "variable type!", &GV); 450f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 451f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // If the global has common linkage, it must have a zero initializer and 452f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // cannot be constant. 453f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (GV.hasCommonLinkage()) { 4549d1a7a8cdb664730cf5703185e85a4716748c564machenbach@chromium.org Assert1(GV.getInitializer()->isNullValue(), 455f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "'common' global must have a zero initializer!", &GV); 456f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!GV.isConstant(), "'common' global may not be marked constant!", 457f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org &GV); 458f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 459f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } else { 460f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(GV.hasExternalLinkage() || GV.hasDLLImportLinkage() || 461f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org GV.hasExternalWeakLinkage(), 462f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "invalid linkage type for global declaration", &GV); 463f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 464f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 465f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (GV.hasName() && (GV.getName() == "llvm.global_ctors" || 4665533f7fe6473bcffd84fdefc0b9ea9f92bdab978machenbach@chromium.org GV.getName() == "llvm.global_dtors")) { 4675533f7fe6473bcffd84fdefc0b9ea9f92bdab978machenbach@chromium.org Assert1(!GV.hasInitializer() || GV.hasAppendingLinkage(), 468f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "invalid linkage for intrinsic global variable", &GV); 469f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Don't worry about emitting an error for it not being an array, 470f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // visitGlobalValue will complain on appending non-array. 47132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getType())) { 472a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org StructType *STy = dyn_cast<StructType>(ATy->getElementType()); 473a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org PointerType *FuncPtrTy = 474a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo(); 475a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(STy && STy->getNumElements() == 2 && 476a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org STy->getTypeAtIndex(0u)->isIntegerTy(32) && 4771510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org STy->getTypeAtIndex(1) == FuncPtrTy, 4787b26015ac58e54e88f4214e248f772ad4f055477whesse@chromium.org "wrong type for intrinsic global variable", &GV); 4797b26015ac58e54e88f4214e248f772ad4f055477whesse@chromium.org } 4807b26015ac58e54e88f4214e248f772ad4f055477whesse@chromium.org } 4817b26015ac58e54e88f4214e248f772ad4f055477whesse@chromium.org 482a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (GV.hasName() && (GV.getName() == "llvm.used" || 48328faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org GV.getName() == "llvm.compiler.used")) { 484169691d93a961c8b511f8ac8fd8ee33d081ca10fdanno@chromium.org Assert1(!GV.hasInitializer() || GV.hasAppendingLinkage(), 48528faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org "invalid linkage for intrinsic global variable", &GV); 48628faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org Type *GVType = GV.getType()->getElementType(); 487a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) { 488a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType()); 489a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(PTy, "wrong type for intrinsic global variable", &GV); 490381adef828187e237e8758ab730dee1c2834a0b3machenbach@chromium.org if (GV.hasInitializer()) { 491381adef828187e237e8758ab730dee1c2834a0b3machenbach@chromium.org Constant *Init = GV.getInitializer(); 4927010a2d84de67daace72568ffcde315a3e510ab5machenbach@chromium.org ConstantArray *InitArray = dyn_cast<ConstantArray>(Init); 493b99c75496e05b4cd58815ada1e39e6029130d11crossberg@chromium.org Assert1(InitArray, "wrong initalizer for intrinsic global variable", 494a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Init); 495a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (unsigned i = 0, e = InitArray->getNumOperands(); i != e; ++i) { 496837a67edd9afdbfe1b59482b41693f59c48846ffulan@chromium.org Value *V = Init->getOperand(i)->stripPointerCastsNoFollowAliases(); 497fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org Assert1( 498fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org isa<GlobalVariable>(V) || isa<Function>(V) || isa<GlobalAlias>(V), 4994e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org "invalid llvm.used member", V); 500ab30bb83bf3dae0053739c57b1db9ad13c1f9e3ayangguo@chromium.org Assert1(V->hasName(), "members of llvm.used must be named", V); 50146839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org } 50246839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org } 503af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org } 50446839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org } 50546839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org 50646839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org if (!GV.hasInitializer()) { 50746839fbbdee40a3d2d924e8b5b13c4139b0b24f2yangguo@chromium.org visitGlobalValue(GV); 508e27d617298263725e8a48c2aa14029759b952623mstarzinger@chromium.org return; 509a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org } 510a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org 511a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org // Walk any aggregate initializers looking for bitcasts between address spaces 512a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org SmallPtrSet<const Value *, 4> Visited; 5134e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org SmallVector<const Value *, 4> WorkStack; 5144e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org WorkStack.push_back(cast<Value>(GV.getInitializer())); 515d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 516d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org while (!WorkStack.empty()) { 517d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org const Value *V = WorkStack.pop_back_val(); 518d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org if (!Visited.insert(V)) 519d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org continue; 520d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 521d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org if (const User *U = dyn_cast<User>(V)) { 522a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (unsigned I = 0, N = U->getNumOperands(); I != N; ++I) 523a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org WorkStack.push_back(U->getOperand(I)); 524a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 525a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 526a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 527a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org VerifyConstantExprBitcastType(CE); 528a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Broken) 529a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return; 530dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org } 531dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org } 532dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 533dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org visitGlobalValue(GV); 534a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 535dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 536dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.orgvoid Verifier::visitGlobalAlias(GlobalAlias &GA) { 537dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(!GA.getName().empty(), 538dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org "Alias name cannot be empty!", &GA); 539dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(GlobalAlias::isValidLinkage(GA.getLinkage()), 540dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org "Alias should have external or external weak linkage!", &GA); 541dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(GA.getAliasee(), 542dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org "Aliasee cannot be NULL!", &GA); 543dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(GA.getType() == GA.getAliasee()->getType(), 544dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org "Alias and aliasee types should match!", &GA); 545dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(!GA.hasUnnamedAddr(), "Alias cannot have unnamed_addr!", &GA); 546dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 547dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Constant *Aliasee = GA.getAliasee(); 548dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 549a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!isa<GlobalValue>(Aliasee)) { 5505924917d324a643d00a8aefee030bd4acea0de0bmachenbach@chromium.org ConstantExpr *CE = dyn_cast<ConstantExpr>(Aliasee); 5515924917d324a643d00a8aefee030bd4acea0de0bmachenbach@chromium.org Assert1(CE && 5525924917d324a643d00a8aefee030bd4acea0de0bmachenbach@chromium.org (CE->getOpcode() == Instruction::BitCast || 5535924917d324a643d00a8aefee030bd4acea0de0bmachenbach@chromium.org CE->getOpcode() == Instruction::GetElementPtr) && 554d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org isa<GlobalValue>(CE->getOperand(0)), 555d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Aliasee should be either GlobalValue or bitcast of GlobalValue", 556d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org &GA); 557d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 558d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (CE->getOpcode() == Instruction::BitCast) { 559d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org unsigned SrcAS = CE->getOperand(0)->getType()->getPointerAddressSpace(); 5602ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org unsigned DstAS = CE->getType()->getPointerAddressSpace(); 5612ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org 5622ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org Assert1(SrcAS == DstAS, 563d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Alias bitcasts cannot be between different address spaces", 564a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org &GA); 565a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 566f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 567f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 568f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org const GlobalValue* Resolved = GA.resolveAliasedGlobal(/*stopOnWeak*/ false); 569f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(Resolved, 570f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Aliasing chain should end with function or global variable", &GA); 571f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 57271f9fca5cfb606009211e0631f33b76cc2ddce3cbmeurer@chromium.org visitGlobalValue(GA); 573a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 574a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 575a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitNamedMDNode(NamedMDNode &NMD) { 57609d7ab5aba54ebac170eac755664c45eefb0be7dulan@chromium.org for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) { 57709d7ab5aba54ebac170eac755664c45eefb0be7dulan@chromium.org MDNode *MD = NMD.getOperand(i); 57809d7ab5aba54ebac170eac755664c45eefb0be7dulan@chromium.org if (!MD) 579a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org continue; 580a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 581a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!MD->isFunctionLocal(), 5823847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com "Named metadata operand cannot be function local!", MD); 583a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitMDNode(*MD, 0); 5844d3fe4e246b0312eba361689f288ddf8dd516960danno@chromium.org } 585fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org} 586a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 587a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitMDNode(MDNode &MD, Function *F) { 588a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Only visit each node once. Metadata can be mutually recursive, so this 5891510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org // avoids infinite recursion here, as well as being an optimization. 590a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!MDNodes.insert(&MD)) 591a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return; 592fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org 593fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org for (unsigned i = 0, e = MD.getNumOperands(); i != e; ++i) { 594fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Value *Op = MD.getOperand(i); 595fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org if (!Op) 596a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org continue; 597fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org if (isa<Constant>(Op) || isa<MDString>(Op)) 598a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org continue; 599d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org if (MDNode *N = dyn_cast<MDNode>(Op)) { 600d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert2(MD.isFunctionLocal() || !N->isFunctionLocal(), 601d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Global metadata operand cannot be function local!", &MD, N); 602d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org visitMDNode(*N, F); 603d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org continue; 604d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org } 605d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert2(MD.isFunctionLocal(), "Invalid operand for global metadata!", &MD, Op); 606d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 607d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org // If this was an instruction, bb, or argument, verify that it is in the 608d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org // function that we expect. 609d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Function *ActualF = 0; 610fb144a0716afe7ab8bf245f2391a9e53b3db3c89fschneider@chromium.org if (Instruction *I = dyn_cast<Instruction>(Op)) 611a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org ActualF = I->getParent()->getParent(); 612ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org else if (BasicBlock *BB = dyn_cast<BasicBlock>(Op)) 613ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org ActualF = BB->getParent(); 614ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org else if (Argument *A = dyn_cast<Argument>(Op)) 615a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org ActualF = A->getParent(); 616a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org assert(ActualF && "Unimplemented function local metadata case!"); 617068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org 618068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org Assert2(ActualF == F, "function-local metadata used in wrong function", 619068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org &MD, Op); 620068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org } 621068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org} 622068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org 623068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.orgvoid Verifier::visitModuleIdents(Module &M) { 624068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident"); 625068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org if (!Idents) 626068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org return; 627068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org 628068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org // llvm.ident takes a list of metadata entry. Each entry has only one string. 629068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org // Scan each llvm.ident entry and make sure that this requirement is met. 630068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) { 631594006017e46d82ed7146611dc12c20e3c509c7ddanno@chromium.org const MDNode *N = Idents->getOperand(i); 632594006017e46d82ed7146611dc12c20e3c509c7ddanno@chromium.org Assert1(N->getNumOperands() == 1, 633068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org "incorrect number of operands in llvm.ident metadata", N); 634068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org Assert1(isa<MDString>(N->getOperand(0)), 635d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org ("invalid value for llvm.ident metadata entry operand" 636d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "(the operand should be a string)"), 637d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org N->getOperand(0)); 638d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org } 6392e04b58f1dc7cee8fdf047b5dbc9dc93e767821dulan@chromium.org} 6402e04b58f1dc7cee8fdf047b5dbc9dc93e767821dulan@chromium.org 6412e04b58f1dc7cee8fdf047b5dbc9dc93e767821dulan@chromium.orgvoid Verifier::visitModuleFlags(Module &M) { 6422e04b58f1dc7cee8fdf047b5dbc9dc93e767821dulan@chromium.org const NamedMDNode *Flags = M.getModuleFlagsMetadata(); 6432e04b58f1dc7cee8fdf047b5dbc9dc93e767821dulan@chromium.org if (!Flags) return; 644528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 645528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org // Scan each flag, and track the flags and requirements. 646068ea0a6ea115c058d1d9798029bd7fa1eaaa955mstarzinger@chromium.org DenseMap<MDString*, MDNode*> SeenIDs; 647528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org SmallVector<MDNode*, 16> Requirements; 648528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org for (unsigned I = 0, E = Flags->getNumOperands(); I != E; ++I) { 649528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org visitModuleFlag(Flags->getOperand(I), SeenIDs, Requirements); 650528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org } 651528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 652528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org // Validate that the requirements in the module are valid. 65394b0d6fcb08a2f01ba52c6edb712068f482366f1danno@chromium.org for (unsigned I = 0, E = Requirements.size(); I != E; ++I) { 65494b0d6fcb08a2f01ba52c6edb712068f482366f1danno@chromium.org MDNode *Requirement = Requirements[I]; 6557c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org MDString *Flag = cast<MDString>(Requirement->getOperand(0)); 6567c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org Value *ReqValue = Requirement->getOperand(1); 657b228be01a466e0ba4d8389148671d196b2081f76mstarzinger@chromium.org 6587c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org MDNode *Op = SeenIDs.lookup(Flag); 659a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!Op) { 660a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org CheckFailed("invalid requirement on flag, flag is not present in module", 661a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Flag); 662f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org continue; 663c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org } 664a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 665a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Op->getOperand(2) != ReqValue) { 6663847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com CheckFailed(("invalid requirement on flag, " 6676d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org "flag does not have the required value"), 6683847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com Flag); 6694b0feeef5d01dbc2948080b4f69daa37e1083461machenbach@chromium.org continue; 6704b0feeef5d01dbc2948080b4f69daa37e1083461machenbach@chromium.org } 6714b0feeef5d01dbc2948080b4f69daa37e1083461machenbach@chromium.org } 6723847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com} 6733847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com 6743847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.comvoid Verifier::visitModuleFlag(MDNode *Op, DenseMap<MDString*, MDNode*>&SeenIDs, 6753847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com SmallVectorImpl<MDNode*> &Requirements) { 676ab30bb83bf3dae0053739c57b1db9ad13c1f9e3ayangguo@chromium.org // Each module flag should have three arguments, the merge behavior (a 677ab30bb83bf3dae0053739c57b1db9ad13c1f9e3ayangguo@chromium.org // constant int), the flag ID (an MDString), and the value. 678ab30bb83bf3dae0053739c57b1db9ad13c1f9e3ayangguo@chromium.org Assert1(Op->getNumOperands() == 3, 679a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "incorrect number of operands in module flag", Op); 680a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org ConstantInt *Behavior = dyn_cast<ConstantInt>(Op->getOperand(0)); 681378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org MDString *ID = dyn_cast<MDString>(Op->getOperand(1)); 682378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org Assert1(Behavior, 683378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org "invalid behavior operand in module flag (expected constant integer)", 68425b0e21ac53cd2e892094493a65f75258fa977f0jkummerow@chromium.org Op->getOperand(0)); 68525b0e21ac53cd2e892094493a65f75258fa977f0jkummerow@chromium.org unsigned BehaviorValue = Behavior->getZExtValue(); 68625b0e21ac53cd2e892094493a65f75258fa977f0jkummerow@chromium.org Assert1(ID, 687378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org "invalid ID operand in module flag (expected metadata string)", 688812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org Op->getOperand(1)); 689c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org 690662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org // Sanity check the values for behaviors with additional requirements. 691662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org switch (BehaviorValue) { 692837a67edd9afdbfe1b59482b41693f59c48846ffulan@chromium.org default: 693837a67edd9afdbfe1b59482b41693f59c48846ffulan@chromium.org Assert1(false, 694c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org "invalid behavior operand in module flag (unexpected constant)", 695812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org Op->getOperand(0)); 696f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org break; 697f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 698f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org case Module::Error: 699f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org case Module::Warning: 700f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org case Module::Override: 701f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // These behavior types accept any value. 702f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org break; 703f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 704f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org case Module::Require: { 705f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // The value should itself be an MDNode with two operands, a flag ID (an 706f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // MDString), and a value. 707f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2)); 708f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(Value && Value->getNumOperands() == 2, 70905ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org "invalid value for 'require' module flag (expected metadata pair)", 710f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Op->getOperand(2)); 71105ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org Assert1(isa<MDString>(Value->getOperand(0)), 71205ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org ("invalid value for 'require' module flag " 713f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "(first value operand should be a string)"), 71405ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org Value->getOperand(0)); 715c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org 716e27d617298263725e8a48c2aa14029759b952623mstarzinger@chromium.org // Append it to the list of requirements, to check once all module flags are 717f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // scanned. 71878d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org Requirements.push_back(Value); 71978d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org break; 72078d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org } 721f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 72278d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org case Module::Append: 72378d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org case Module::AppendUnique: { 72478d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org // These behavior types require the operand be an MDNode. 72578d1ad443658709d6c27809001a0e71efd8b898fyangguo@chromium.org Assert1(isa<MDNode>(Op->getOperand(2)), 72605ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org "invalid value for 'append'-type module flag " 727f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "(expected a metadata node)", Op->getOperand(2)); 72805ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org break; 72905ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org } 730c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org } 7311805e21b0aece8c05f4960a5c0751c4463557891fschneider@chromium.org 7322ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org // Unless this is a "requires" flag, check the ID is unique. 7332ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org if (BehaviorValue != Module::Require) { 7342ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second; 7352ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org Assert1(Inserted, 7362ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org "module flag identifiers must be unique (or of 'require' type)", 7372ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org ID); 7382ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org } 7392ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org} 7402ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org 7412ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.orgvoid Verifier::VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, 7422ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org bool isFunction, const Value *V) { 743812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org unsigned Slot = ~0U; 744a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I) 745812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org if (Attrs.getSlotIndex(I) == Idx) { 746a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Slot = I; 74793a47f4837f2137c8d8349250fd8e91da3108126jkummerow@chromium.org break; 74893a47f4837f2137c8d8349250fd8e91da3108126jkummerow@chromium.org } 749639bac0c5319f96e1bbe3399fb7f7f37344928bddslomov@chromium.org 75093a47f4837f2137c8d8349250fd8e91da3108126jkummerow@chromium.org assert(Slot != ~0U && "Attribute set inconsistency!"); 751a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 752fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org for (AttributeSet::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot); 753fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org I != E; ++I) { 7547028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org if (I->isStringAttribute()) 755fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org continue; 7561510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org 7577028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org if (I->getKindAsEnum() == Attribute::NoReturn || 758a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::NoUnwind || 759a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::NoInline || 760a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::AlwaysInline || 761a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::OptimizeForSize || 762a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::StackProtect || 763a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::StackProtectReq || 7643a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org I->getKindAsEnum() == Attribute::StackProtectStrong || 7653a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org I->getKindAsEnum() == Attribute::NoRedZone || 766a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::NoImplicitFloat || 7679259716434187c932704601f700375e53d865de8rossberg@chromium.org I->getKindAsEnum() == Attribute::Naked || 7683d079fe881245e49c7ba803b54b4fe6d4b46113cmachenbach@chromium.org I->getKindAsEnum() == Attribute::InlineHint || 769e27d617298263725e8a48c2aa14029759b952623mstarzinger@chromium.org I->getKindAsEnum() == Attribute::StackAlignment || 770a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::UWTable || 771f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org I->getKindAsEnum() == Attribute::NonLazyBind || 772a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::ReturnsTwice || 773dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org I->getKindAsEnum() == Attribute::SanitizeAddress || 774a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::SanitizeThread || 775d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::SanitizeMemory || 776d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::MinSize || 777d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::NoDuplicate || 778d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::Builtin || 779d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::NoBuiltin || 780d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::Cold || 781d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org I->getKindAsEnum() == Attribute::OptimizeNone) { 782d16d8531698e91e9c60a7db9e0ba3c3bb15aff20mvstanton@chromium.org if (!isFunction) { 783a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org CheckFailed("Attribute '" + I->getAsString() + 784a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "' only applies to functions!", V); 785a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return; 786a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 7873a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org } else if (I->getKindAsEnum() == Attribute::ReadOnly || 788a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org I->getKindAsEnum() == Attribute::ReadNone) { 78928faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org if (Idx == 0) { 79028faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org CheckFailed("Attribute '" + I->getAsString() + 79128faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org "' does not apply to function returns"); 7928297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org return; 7938297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org } 794169691d93a961c8b511f8ac8fd8ee33d081ca10fdanno@chromium.org } else if (isFunction) { 79528faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org CheckFailed("Attribute '" + I->getAsString() + 7968297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org "' does not apply to functions!", V); 79728faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org return; 79828faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org } 7994e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org } 8004e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org} 8014e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org 802c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org// VerifyParameterAttrs - Check the given attributes for an argument or return 803c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org// value of the specified type. The value V is printed in error messages. 804a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, 805378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org bool isReturnValue, const Value *V) { 806a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!Attrs.hasAttributes(Idx)) 807a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return; 808876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 809876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org VerifyAttributeTypes(Attrs, Idx, false, V); 810876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org 811876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org if (isReturnValue) 812876cca833d7212e476250d102cad185cdcfa9dfesvenpanne@chromium.org Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal) && 8137c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org !Attrs.hasAttribute(Idx, Attribute::Nest) && 8147c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org !Attrs.hasAttribute(Idx, Attribute::StructRet) && 8157c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org !Attrs.hasAttribute(Idx, Attribute::NoCapture) && 816d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org !Attrs.hasAttribute(Idx, Attribute::Returned), 817d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Attribute 'byval', 'nest', 'sret', 'nocapture', and 'returned' " 818d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "do not apply to return values!", V); 819eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org 820d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Check for mutually incompatible attributes. 821d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(!((Attrs.hasAttribute(Idx, Attribute::ByVal) && 822d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Attrs.hasAttribute(Idx, Attribute::Nest)) || 823d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org (Attrs.hasAttribute(Idx, Attribute::ByVal) && 824d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Attrs.hasAttribute(Idx, Attribute::StructRet)) || 825eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org (Attrs.hasAttribute(Idx, Attribute::Nest) && 826d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Attrs.hasAttribute(Idx, Attribute::StructRet))), "Attributes " 827d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "'byval, nest, and sret' are incompatible!", V); 8288fa5bd929d2f128e3d554398bd085b3c2f98e23bjkummerow@chromium.org 8298fa5bd929d2f128e3d554398bd085b3c2f98e23bjkummerow@chromium.org Assert1(!((Attrs.hasAttribute(Idx, Attribute::ByVal) && 8308fa5bd929d2f128e3d554398bd085b3c2f98e23bjkummerow@chromium.org Attrs.hasAttribute(Idx, Attribute::Nest)) || 8318fa5bd929d2f128e3d554398bd085b3c2f98e23bjkummerow@chromium.org (Attrs.hasAttribute(Idx, Attribute::ByVal) && 8328fa5bd929d2f128e3d554398bd085b3c2f98e23bjkummerow@chromium.org Attrs.hasAttribute(Idx, Attribute::InReg)) || 833a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org (Attrs.hasAttribute(Idx, Attribute::Nest) && 834378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org Attrs.hasAttribute(Idx, Attribute::InReg))), "Attributes " 835378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org "'byval, nest, and inreg' are incompatible!", V); 8363a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 837378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org Assert1(!(Attrs.hasAttribute(Idx, Attribute::StructRet) && 838378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org Attrs.hasAttribute(Idx, Attribute::Returned)), "Attributes " 839378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org "'sret and returned' are incompatible!", V); 840fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org 841eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org Assert1(!(Attrs.hasAttribute(Idx, Attribute::ZExt) && 842eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org Attrs.hasAttribute(Idx, Attribute::SExt)), "Attributes " 843eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org "'zeroext and signext' are incompatible!", V); 844eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org 845eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org Assert1(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) && 846eac65cd57a2d5f018fc440eed1b69d0fe80fe336machenbach@chromium.org Attrs.hasAttribute(Idx, Attribute::ReadOnly)), "Attributes " 847fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org "'readnone and readonly' are incompatible!", V); 848fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org 849fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(!(Attrs.hasAttribute(Idx, Attribute::NoInline) && 850a86d416fb652b1936026eee315eccd4f17ca1002machenbach@chromium.org Attrs.hasAttribute(Idx, Attribute::AlwaysInline)), "Attributes " 851b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org "'noinline and alwaysinline' are incompatible!", V); 852fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org 853fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(!AttrBuilder(Attrs, Idx). 8541510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx), 855fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org "Wrong types for attribute: " + 8561510d58cbcf57c82a10e7d390bfe21a7ae68ba43mstarzinger@chromium.org AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx), V); 857fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org 858a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (PointerType *PTy = dyn_cast<PointerType>(Ty)) 859fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal) || 860812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org PTy->getElementType()->isSized(), 861a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Attribute 'byval' does not support unsized types!", V); 8623a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org else 863a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal), 864a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Attribute 'byval' only applies to parameters with pointer type!", 865a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org V); 866a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 867a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 868a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// VerifyFunctionAttrs - Check parameter attributes against a function type. 869a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org// The value V is printed in error messages. 870a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, 871a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org const Value *V) { 872a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Attrs.isEmpty()) 873f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org return; 874052c9560e8a41c723726ebe914a93747d8f13285hpayer@chromium.org 875f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org bool SawNest = false; 87628faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org bool SawReturned = false; 87728faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org 8781805e21b0aece8c05f4960a5c0751c4463557891fschneider@chromium.org for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { 8791805e21b0aece8c05f4960a5c0751c4463557891fschneider@chromium.org unsigned Idx = Attrs.getSlotIndex(i); 8801805e21b0aece8c05f4960a5c0751c4463557891fschneider@chromium.org 8811805e21b0aece8c05f4960a5c0751c4463557891fschneider@chromium.org Type *Ty; 882378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org if (Idx == 0) 88305ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org Ty = FT->getReturnType(); 884f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org else if (Idx-1 < FT->getNumParams()) 885f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Ty = FT->getParamType(Idx-1); 88605ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org else 887378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org break; // VarArgs attributes, verified elsewhere. 888f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 889378b34e3f8852e94739bb77a528278fe0e2bb532ager@chromium.org VerifyParameterAttrs(Attrs, Idx, Ty, Idx == 0, V); 890c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org 891c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org if (Idx == 0) 89205ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org continue; 893f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 894f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 895f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!SawNest, "More than one parameter has attribute nest!", V); 896f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org SawNest = true; 897f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 89805ed9ddc6ff3a1ab3983c50d378cddfa257869b6jkummerow@chromium.org 899c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 900c3b37129d6387b2db313f9100256d2d5f60dd9a8jkummerow@chromium.org Assert1(!SawReturned, "More than one parameter has attribute returned!", 9013847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com V); 9023847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com Assert1(Ty->canLosslesslyBitCastTo(FT->getReturnType()), "Incompatible " 9033847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com "argument and return types for 'returned' attribute", V); 9043847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com SawReturned = true; 905a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 906a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 907a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Attrs.hasAttribute(Idx, Attribute::StructRet)) 908a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(Idx == 1, "Attribute sret is not on first parameter!", V); 909a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 910a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 911a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!Attrs.hasAttributes(AttributeSet::FunctionIndex)) 912a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org return; 913a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 914a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V); 9153847bd5ff857259e945a01d75fdb383e2351d166erik.corry@gmail.com 916a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex, 9172ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org Attribute::ReadNone) && 9182ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org Attrs.hasAttribute(AttributeSet::FunctionIndex, 9192ebef182c49d59eba907b120c3c2a50808bd1f12machenbach@chromium.org Attribute::ReadOnly)), 920a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Attributes 'readnone and readonly' are incompatible!", V); 921f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 922f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex, 923a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Attribute::NoInline) && 924659ceec4628056d3c6e7076c850fba1c412cbb8ayangguo@chromium.org Attrs.hasAttribute(AttributeSet::FunctionIndex, 925c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org Attribute::AlwaysInline)), 926c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org "Attributes 'noinline and alwaysinline' are incompatible!", V); 927a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 928a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 929a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Attribute::OptimizeNone)) { 930f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(Attrs.hasAttribute(AttributeSet::FunctionIndex, 931f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Attribute::NoInline), 932f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Attribute 'optnone' requires 'noinline'!", V); 933f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 934f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex, 935f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Attribute::OptimizeForSize), 936f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Attributes 'optsize and optnone' are incompatible!", V); 937f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 938f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex, 939f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Attribute::MinSize), 940f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Attributes 'minsize and optnone' are incompatible!", V); 941f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org } 942f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org} 943f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 944f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.orgvoid Verifier::VerifyBitcastType(const Value *V, Type *DestTy, Type *SrcTy) { 945f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Get the size of the types in bits, we'll need this later 946f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); 947f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); 948a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 949d0bddc653152f270a27fe32d5d7b0f5c0fa3b00cmachenbach@chromium.org // BitCast implies a no-op cast of type only. No bits change. 950f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // However, you can't cast pointers to anything but pointers. 951f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(SrcTy->isPointerTy() == DestTy->isPointerTy(), 952f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Bitcast requires both operands to be pointer or neither", V); 953d0bddc653152f270a27fe32d5d7b0f5c0fa3b00cmachenbach@chromium.org Assert1(SrcBitSize == DestBitSize, 954d0bddc653152f270a27fe32d5d7b0f5c0fa3b00cmachenbach@chromium.org "Bitcast requires types of same width", V); 955d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 956d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Disallow aggregates. 957d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(!SrcTy->isAggregateType(), 958d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Bitcast operand must not be aggregate", V); 959d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(!DestTy->isAggregateType(), 960d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Bitcast type must not be aggregate", V); 961d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 962d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Without datalayout, assume all address spaces are the same size. 963d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Don't check if both types are not pointers. 964d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Skip casts between scalars and vectors. 965d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (!DL || 966d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org !SrcTy->isPtrOrPtrVectorTy() || 967d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org !DestTy->isPtrOrPtrVectorTy() || 968d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org SrcTy->isVectorTy() != DestTy->isVectorTy()) { 969d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org return; 970d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 971d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 972d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org unsigned SrcAS = SrcTy->getPointerAddressSpace(); 973d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org unsigned DstAS = DestTy->getPointerAddressSpace(); 974d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 975d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(SrcAS == DstAS, 976d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Bitcasts between pointers of different address spaces is not legal." 977d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Use AddrSpaceCast instead.", V); 978d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org} 979d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 980d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.orgvoid Verifier::VerifyConstantExprBitcastType(const ConstantExpr *CE) { 981d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (CE->getOpcode() == Instruction::BitCast) { 982d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Type *SrcTy = CE->getOperand(0)->getType(); 983d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Type *DstTy = CE->getType(); 984d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org VerifyBitcastType(CE, DstTy, SrcTy); 985d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 986d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org} 987d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 988d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.orgbool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) { 989d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (Attrs.getNumSlots() == 0) 990d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org return true; 991d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 992d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org unsigned LastSlot = Attrs.getNumSlots() - 1; 993d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org unsigned LastIndex = Attrs.getSlotIndex(LastSlot); 994d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (LastIndex <= Params 995d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org || (LastIndex == AttributeSet::FunctionIndex 996fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params))) 997fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org return true; 998fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org 999fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org return false; 1000fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org} 1001fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org 1002fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org// visitFunction - Verify that a function is ok. 1003fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org// 1004fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.orgvoid Verifier::visitFunction(Function &F) { 1005fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org // Check function arguments. 1006fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org FunctionType *FT = F.getFunctionType(); 1007fb547e07aef43e02715c5d6c1530e84bb3cbba02machenbach@chromium.org unsigned NumArgs = F.arg_size(); 10088e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10098e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(Context == &F.getContext(), 10108e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "Function context does not match Module context!", &F); 10118e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10128e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(!F.hasCommonLinkage(), "Functions may not have common linkage", &F); 10138e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert2(FT->getNumParams() == NumArgs, 10148e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "# formal arguments must match # of arguments for function type!", 10158e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org &F, FT); 10168e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(F.getReturnType()->isFirstClassType() || 10178e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org F.getReturnType()->isVoidTy() || 10188e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org F.getReturnType()->isStructTy(), 10198e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "Functions cannot return aggregate values!", &F); 10208e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10218e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(), 10228e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "Invalid struct return type!", &F); 10238e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10248e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org AttributeSet Attrs = F.getAttributes(); 10258e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10268e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(VerifyAttributeCount(Attrs, FT->getNumParams()), 10278e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "Attribute after last parameter!", &F); 10288e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10298e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // Check function attributes. 10308e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org VerifyFunctionAttrs(FT, Attrs, &F); 10318e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10328e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // On function declarations/definitions, we do not support the builtin 10338e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // attribute. We do not check this in VerifyFunctionAttrs since that is 10348e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // checking for Attributes that can/can not ever be on functions. 10358e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex, 10368e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Attribute::Builtin), 10378e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "Attribute 'builtin' can only be applied to a callsite.", &F); 10388e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 10398e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // Check that this function meets the restrictions on this calling convention. 10408e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org switch (F.getCallingConv()) { 10418e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org default: 10428e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org break; 10438e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case CallingConv::C: 10448e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org break; 10458e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case CallingConv::Fast: 10468e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case CallingConv::Cold: 10478e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case CallingConv::X86_FastCall: 10488e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case CallingConv::X86_ThisCall: 1049d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org case CallingConv::Intel_OCL_BI: 1050af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org case CallingConv::PTX_Kernel: 1051af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org case CallingConv::PTX_Device: 1052af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(!F.isVarArg(), 1053af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "Varargs functions must have C calling conventions!", &F); 1054af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org break; 1055af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org } 1056af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1057af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org bool isLLVMdotName = F.getName().size() >= 5 && 1058af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org F.getName().substr(0, 5) == "llvm."; 1059af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1060af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Check that the argument values match the function type for this function... 1061f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org unsigned i = 0; 1062af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); 1063f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org I != E; ++I, ++i) { 1064af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert2(I->getType() == FT->getParamType(i), 1065f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Argument value does not match function argument type!", 1066af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org I, FT->getParamType(i)); 1067af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(I->getType()->isFirstClassType(), 1068f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Function arguments must have first-class types!", I); 1069af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org if (!isLLVMdotName) 1070af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert2(!I->getType()->isMetadataTy(), 1071af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "Function takes metadata but isn't an intrinsic", I, &F); 1072f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 1073af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1074af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org if (F.isMaterializable()) { 1075af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Function has a body somewhere we can't see. 1076af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org } else if (F.isDeclaration()) { 1077af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() || 1078af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org F.hasExternalWeakLinkage(), 1079af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "invalid linkage type for function declaration", &F); 1080af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org } else { 1081af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Verify that this function (which has a body) is not named "llvm.*". It 1082f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // is not legal to define intrinsics. 1083f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F); 1084af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1085f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // Check the entry node 1086af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org BasicBlock *Entry = &F.getEntryBlock(); 1087af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(pred_begin(Entry) == pred_end(Entry), 1088f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Entry block to function must not have predecessors!", Entry); 1089af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1090af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // The address of the entry block cannot be taken, unless it is dead. 1091af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org if (Entry->hasAddressTaken()) { 1092af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(!BlockAddress::get(Entry)->isConstantUsed(), 1093af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "blockaddress may not be used with the entry block!", Entry); 1094af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org } 1095f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 1096af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1097af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // If this function is actually an intrinsic, verify that it is only used in 1098af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // direct call/invokes, never having its "address taken". 1099f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (F.getIntrinsicID()) { 1100af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org const User *U; 1101af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org if (F.hasAddressTaken(&U)) 1102f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(0, "Invalid user of intrinsic instruction!", U); 1103af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org } 1104af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org} 1105af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1106af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org// verifyBasicBlock - Verify that a basic block is well formed... 1107af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org// 1108af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.orgvoid Verifier::visitBasicBlock(BasicBlock &BB) { 1109af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org InstsInThisBlock.clear(); 1110f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 1111af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Ensure that basic blocks have terminators! 1112af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(BB.getTerminator(), "Basic Block does not have terminator!", &BB); 1113af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1114af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Check constraints that this basic block imposes on all of the PHI nodes in 1115af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // it. 1116af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org if (isa<PHINode>(BB.front())) { 1117af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org SmallVector<BasicBlock*, 8> Preds(pred_begin(&BB), pred_end(&BB)); 1118af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org SmallVector<std::pair<BasicBlock*, Value*>, 8> Values; 1119f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org std::sort(Preds.begin(), Preds.end()); 1120af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org PHINode *PN; 1121f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) { 1122af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Ensure that PHI nodes have at least one entry! 1123af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(PN->getNumIncomingValues() != 0, 1124af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "PHI nodes must have at least one entry. If the block is dead, " 1125af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "the PHI should be removed!", PN); 1126af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert1(PN->getNumIncomingValues() == Preds.size(), 1127af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "PHINode should have one entry for each predecessor of its " 1128af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "parent basic block!", PN); 1129af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1130af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Get and sort all incoming values in the PHI node... 1131af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Values.clear(); 1132af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Values.reserve(PN->getNumIncomingValues()); 1133af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 1134af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Values.push_back(std::make_pair(PN->getIncomingBlock(i), 1135af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org PN->getIncomingValue(i))); 1136af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org std::sort(Values.begin(), Values.end()); 1137af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org 1138af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org for (unsigned i = 0, e = Values.size(); i != e; ++i) { 1139af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Check to make sure that if there is more than one entry for a 1140af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // particular basic block in this PHI node, that the incoming values are 1141af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // all identical. 1142af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // 114332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert4(i == 0 || Values[i].first != Values[i-1].first || 1144a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Values[i].second == Values[i-1].second, 1145a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "PHI node has multiple entries for the same basic block with " 1146a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "different incoming values!", PN, Values[i].first, 1147a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Values[i].second, Values[i-1].second); 1148f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 1149f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Check to make sure that the predecessors and PHI node entries are 1150a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // matched up. 1151a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert3(Values[i].first == Preds[i], 1152a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "PHI node entries do not match predecessors!", PN, 1153af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org Values[i].first, Preds[i]); 1154a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 1155af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org } 1156af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org } 1157af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org} 1158af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org 1159af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.orgvoid Verifier::visitTerminatorInst(TerminatorInst &I) { 1160af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org // Ensure that terminators only exist at the end of the basic block. 1161a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(&I == I.getParent()->getTerminator(), 1162a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Terminator found in the middle of a basic block!", I.getParent()); 1163af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org visitInstruction(I); 1164af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org} 1165af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org 1166af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.orgvoid Verifier::visitBranchInst(BranchInst &BI) { 1167af4fba3c6d2a18866505de3e6798757dd1448c6dmachenbach@chromium.org if (BI.isConditional()) { 116828583c92ca8f528df625800519088ac88996d504jkummerow@chromium.org Assert2(BI.getCondition()->getType()->isIntegerTy(1), 1169f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Branch condition is not 'i1' type!", &BI, BI.getCondition()); 1170f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org } 1171af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org visitTerminatorInst(BI); 1172af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org} 1173f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 1174af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.orgvoid Verifier::visitReturnInst(ReturnInst &RI) { 1175f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Function *F = RI.getParent()->getParent(); 117628583c92ca8f528df625800519088ac88996d504jkummerow@chromium.org unsigned N = RI.getNumOperands(); 1177f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org if (F->getReturnType()->isVoidTy()) 1178af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org Assert2(N == 0, 1179af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "Found return instr that returns non-void in Function of void " 1180af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "return type!", &RI, F->getReturnType()); 1181f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org else 1182f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert2(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(), 1183f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org "Function return type does not match operand " 1184af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org "type of return inst!", &RI, F->getReturnType()); 1185f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org 1186af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // Check to make sure that the return value has necessary properties for 1187af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org // terminators... 1188af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org visitTerminatorInst(RI); 118928583c92ca8f528df625800519088ac88996d504jkummerow@chromium.org} 1190a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 119138de99aae2d4efc5796aa6935c1648447ec32fc8machenbach@chromium.orgvoid Verifier::visitSwitchInst(SwitchInst &SI) { 1192ed1a63112185152bc10fbd02418393804a5fcf04machenbach@chromium.org // Check to make sure that all of the constants in the switch instruction 1193812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org // have the same type as the switched-on value. 1194812308e1488cd8261e4dbbda1d8022642d522b9bulan@chromium.org Type *SwitchTy = SI.getCondition()->getType(); 1195a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org SmallPtrSet<ConstantInt*, 32> Constants; 1196a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) { 1197a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(i.getCaseValue()->getType() == SwitchTy, 119832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "Switch constants must all be same type as switch value!", &SI); 1199a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert2(Constants.insert(i.getCaseValue()), 1200a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Duplicate integer as switch case", &SI, i.getCaseValue()); 1201b5ed9300c59e8590c9dc588727b6564c244b0f5cmachenbach@chromium.org } 1202b5ed9300c59e8590c9dc588727b6564c244b0f5cmachenbach@chromium.org 1203ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org visitTerminatorInst(SI); 12043a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org} 1205dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 1206a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitIndirectBrInst(IndirectBrInst &BI) { 1207a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(BI.getAddress()->getType()->isPointerTy(), 1208d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Indirectbr operand must have pointer type!", &BI); 1209d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i) 1210d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(BI.getDestination(i)->getType()->isLabelTy(), 1211a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Indirectbr destinations must all have pointer type!", &BI); 1212a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1213f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org visitTerminatorInst(BI); 1214a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1215a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 121632cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.orgvoid Verifier::visitSelectInst(SelectInst &SI) { 1217a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1), 1218a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org SI.getOperand(2)), 1219a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Invalid operands for select instruction!", &SI); 1220a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1221a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(SI.getTrueValue()->getType() == SI.getType(), 1222a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Select values must have same type as select instruction!", &SI); 1223a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(SI); 1224a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1225a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1226af9cfcbed5daf6e636e189bce451c6fafdbb127dmachenbach@chromium.org/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of 1227a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// a pass, if any exist, it's an error. 1228a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// 1229a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitUserOp1(Instruction &I) { 1230a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(0, "User-defined operators should not live outside of a pass!", &I); 1231a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 12326d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org 12336d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.orgvoid Verifier::visitTruncInst(TruncInst &I) { 1234a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Get the source and destination types 1235f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 123632cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Type *DestTy = I.getType(); 123732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 123832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Get the size of the types in bits, we'll need this later 1239a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 12406d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1241d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1242d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I); 124332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I); 124432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 124532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "trunc source and destination must both be a vector or neither", &I); 12460a4e901cdfb5505a896d30aa8c2e04fce0fbe069vegorov@chromium.org Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I); 12470a4e901cdfb5505a896d30aa8c2e04fce0fbe069vegorov@chromium.org 12486d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org visitInstruction(I); 1249a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1250a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1251a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitZExtInst(ZExtInst &I) { 125232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Get the source and destination types 12533a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1254f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Type *DestTy = I.getType(); 1255f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 12564f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org // Get the size of the types in bits, we'll need this later 12573a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I); 1258f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I); 12593a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1260d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "zext source and destination must both be a vector or neither", &I); 1261d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1262d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1263d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1264d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcBitSize < DestBitSize,"Type too small for ZExt", &I); 12656d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org 12666d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org visitInstruction(I); 12673a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org} 12686d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org 12696d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.orgvoid Verifier::visitSExtInst(SExtInst &I) { 12706d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org // Get the source and destination types 12716d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1272528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Type *DestTy = I.getType(); 1273528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 1274528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org // Get the size of the types in bits, we'll need this later 1275528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 1276528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org unsigned DestBitSize = DestTy->getScalarSizeInBits(); 1277528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 12786d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Assert1(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I); 12793a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I); 12803a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 12813a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "sext source and destination must both be a vector or neither", &I); 128232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I); 12833a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 1284f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org visitInstruction(I); 1285f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org} 12863a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 12876d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.orgvoid Verifier::visitFPTruncInst(FPTruncInst &I) { 12886d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org // Get the source and destination types 12896d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 12903a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Type *DestTy = I.getType(); 12913a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org // Get the size of the types in bits, we'll need this later 1292f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 12936d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org unsigned DestBitSize = DestTy->getScalarSizeInBits(); 12943a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 12953a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcTy->isFPOrFPVectorTy(),"FPTrunc only operates on FP", &I); 12963a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(DestTy->isFPOrFPVectorTy(),"FPTrunc only produces an FP", &I); 12976d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 129832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "fptrunc source and destination must both be a vector or neither",&I); 12993a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I); 1300f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 1301f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org visitInstruction(I); 130232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org} 130332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 130432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.orgvoid Verifier::visitFPExtInst(FPExtInst &I) { 13056d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org // Get the source and destination types 1306f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 130732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Type *DestTy = I.getType(); 13083a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 13094f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.org // Get the size of the types in bits, we'll need this later 13103a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); 131132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org unsigned DestBitSize = DestTy->getScalarSizeInBits(); 131232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 131332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcTy->isFPOrFPVectorTy(),"FPExt only operates on FP", &I); 13143a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(DestTy->isFPOrFPVectorTy(),"FPExt only produces an FP", &I); 13153a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 13166d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org "fpext source and destination must both be a vector or neither", &I); 13176d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I); 13183a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 13193a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org visitInstruction(I); 13203a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org} 132132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 13223a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.orgvoid Verifier::visitUIToFPInst(UIToFPInst &I) { 132332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Get the source and destination types 13243a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 13253a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Type *DestTy = I.getType(); 13263a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 1327dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org bool SrcVec = SrcTy->isVectorTy(); 13283a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org bool DstVec = DestTy->isVectorTy(); 13293a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 13303a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(SrcVec == DstVec, 133132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "UIToFP source and dest must both be vector or scalar", &I); 133246a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org Assert1(SrcTy->isIntOrIntVectorTy(), 1333d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "UIToFP source must be integer or integer vector", &I); 1334d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(DestTy->isFPOrFPVectorTy(), 133546a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org "UIToFP result must be FP or FP vector", &I); 133646a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org 133746a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org if (SrcVec && DstVec) 133846a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org Assert1(cast<VectorType>(SrcTy)->getNumElements() == 133946a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org cast<VectorType>(DestTy)->getNumElements(), 134046a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org "UIToFP source and dest vector length mismatch", &I); 1341f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 134246a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org visitInstruction(I); 134332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org} 134432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 134546a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.orgvoid Verifier::visitSIToFPInst(SIToFPInst &I) { 134646a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org // Get the source and destination types 134746a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1348f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Type *DestTy = I.getType(); 134946a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org 135046a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org bool SrcVec = SrcTy->isVectorTy(); 135146a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org bool DstVec = DestTy->isVectorTy(); 135246a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org 135346a2a51ad190697e0f62c3060ce02a9de5820a07yangguo@chromium.org Assert1(SrcVec == DstVec, 13544e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org "SIToFP source and dest must both be vector or scalar", &I); 135532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcTy->isIntOrIntVectorTy(), 13564e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org "SIToFP source must be integer or integer vector", &I); 1357528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(DestTy->isFPOrFPVectorTy(), 1358528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "SIToFP result must be FP or FP vector", &I); 135932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 13604e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org if (SrcVec && DstVec) 13614e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org Assert1(cast<VectorType>(SrcTy)->getNumElements() == 13624e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org cast<VectorType>(DestTy)->getNumElements(), 13634e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org "SIToFP source and dest vector length mismatch", &I); 13644e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org 13654e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org visitInstruction(I); 13664e308cf00936c6e7bead43e5141a04e37b49b9b5jkummerow@chromium.org} 136732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1368a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitFPToUIInst(FPToUIInst &I) { 136904921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // Get the source and destination types 1370c3b670ff19220959730d7886892bc4beb95d2ebaerik.corry@gmail.com Type *SrcTy = I.getOperand(0)->getType(); 1371c3b670ff19220959730d7886892bc4beb95d2ebaerik.corry@gmail.com Type *DestTy = I.getType(); 1372a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1373d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org bool SrcVec = SrcTy->isVectorTy(); 1374d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org bool DstVec = DestTy->isVectorTy(); 1375d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1376d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcVec == DstVec, 1377d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "FPToUI source and dest must both be vector or scalar", &I); 137832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector", 13793a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org &I); 13803a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(DestTy->isIntOrIntVectorTy(), 13813a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "FPToUI result must be integer or integer vector", &I); 1382f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 138383e168294456ca2f02db421a635f7d5f5d023966kmillikin@chromium.org if (SrcVec && DstVec) 1384dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(cast<VectorType>(SrcTy)->getNumElements() == 1385a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org cast<VectorType>(DestTy)->getNumElements(), 1386a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "FPToUI source and dest vector length mismatch", &I); 1387a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1388d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org visitInstruction(I); 1389d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org} 1390f9841897146bc10dbb3c45f0632bb79254602c75machenbach@chromium.org 1391f9841897146bc10dbb3c45f0632bb79254602c75machenbach@chromium.orgvoid Verifier::visitFPToSIInst(FPToSIInst &I) { 1392f9841897146bc10dbb3c45f0632bb79254602c75machenbach@chromium.org // Get the source and destination types 1393f9841897146bc10dbb3c45f0632bb79254602c75machenbach@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1394f9841897146bc10dbb3c45f0632bb79254602c75machenbach@chromium.org Type *DestTy = I.getType(); 1395d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1396d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org bool SrcVec = SrcTy->isVectorTy(); 1397d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org bool DstVec = DestTy->isVectorTy(); 1398d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1399d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcVec == DstVec, 1400d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "FPToSI source and dest must both be vector or scalar", &I); 1401d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcTy->isFPOrFPVectorTy(), 1402d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "FPToSI source must be FP or FP vector", &I); 1403d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(DestTy->isIntOrIntVectorTy(), 1404d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "FPToSI result must be integer or integer vector", &I); 1405d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1406d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org if (SrcVec && DstVec) 1407d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(cast<VectorType>(SrcTy)->getNumElements() == 1408d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org cast<VectorType>(DestTy)->getNumElements(), 1409d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "FPToSI source and dest vector length mismatch", &I); 1410d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1411d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org visitInstruction(I); 1412d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org} 1413d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1414d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.orgvoid Verifier::visitPtrToIntInst(PtrToIntInst &I) { 1415d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org // Get the source and destination types 1416d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1417d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Type *DestTy = I.getType(); 1418d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1419d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcTy->getScalarType()->isPointerTy(), 1420d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "PtrToInt source must be pointer", &I); 1421d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(DestTy->getScalarType()->isIntegerTy(), 1422d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "PtrToInt result must be integral", &I); 1423d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1424d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "PtrToInt type mismatch", &I); 142532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1426a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (SrcTy->isVectorTy()) { 14276d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 14286d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org VectorType *VDest = dyn_cast<VectorType>(DestTy); 14296d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org Assert1(VSrc->getNumElements() == VDest->getNumElements(), 1430a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "PtrToInt Vector width mismatch", &I); 14316d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org } 14326d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org 1433a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(I); 1434a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1435f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 1436a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitIntToPtrInst(IntToPtrInst &I) { 1437f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Get the source and destination types 1438a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1439a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Type *DestTy = I.getType(); 1440a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 144132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(SrcTy->getScalarType()->isIntegerTy(), 1442a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "IntToPtr source must be an integral", &I); 1443528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(DestTy->getScalarType()->isPointerTy(), 1444528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "IntToPtr result must be a pointer",&I); 1445528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(), 1446528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "IntToPtr type mismatch", &I); 1447528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org if (SrcTy->isVectorTy()) { 1448528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org VectorType *VSrc = dyn_cast<VectorType>(SrcTy); 1449a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org VectorType *VDest = dyn_cast<VectorType>(DestTy); 145032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(VSrc->getNumElements() == VDest->getNumElements(), 1451a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "IntToPtr Vector width mismatch", &I); 1452a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 145332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org visitInstruction(I); 1454a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1455d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 1456d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.orgvoid Verifier::visitBitCastInst(BitCastInst &I) { 1457f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 1458a77ec9c2cf67e5b9c707fe42f33574526fed189amachenbach@chromium.org Type *DestTy = I.getType(); 14592c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org VerifyBitcastType(&I, DestTy, SrcTy); 14602c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org visitInstruction(I); 14612c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org} 14622c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org 14634f693d6b99ffdbc05e5e211e08ed5039e13279d2ricow@chromium.orgvoid Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) { 14642c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org Type *SrcTy = I.getOperand(0)->getType(); 14652c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org Type *DestTy = I.getType(); 1466528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 1467528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(SrcTy->isPtrOrPtrVectorTy(), 1468528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "AddrSpaceCast source must be a pointer", &I); 1469528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(DestTy->isPtrOrPtrVectorTy(), 1470528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "AddrSpaceCast result must be a pointer", &I); 1471528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(), 1472528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "AddrSpaceCast must be between different address spaces", &I); 1473528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org if (SrcTy->isVectorTy()) 1474528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(), 14752c99e28a7b1fcb3767dc7c0088514fe53be784c5ricow@chromium.org "AddrSpaceCast vector pointer number of elements mismatch", &I); 1476a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(I); 1477a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1478a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 147932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org/// visitPHINode - Ensure that a PHI node is well formed. 1480a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// 1481052c9560e8a41c723726ebe914a93747d8f13285hpayer@chromium.orgvoid Verifier::visitPHINode(PHINode &PN) { 1482052c9560e8a41c723726ebe914a93747d8f13285hpayer@chromium.org // Ensure that the PHI nodes are all grouped together at the top of the block. 1483528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org // This can be tested by checking whether the instruction before this is 1484a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // either nonexistent (because this is begin()) or is a PHI node. If not, 14858297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org // then there is some other instruction before a PHI. 14868297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org Assert2(&PN == &PN.getParent()->front() || 14878297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org isa<PHINode>(--BasicBlock::iterator(&PN)), 14888297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org "PHI nodes not grouped at top of basic block!", 14898297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org &PN, PN.getParent()); 14908297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org 14918297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org // Check that all of the values of the PHI node have the same type as the 14928297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org // result, and that the incoming blocks are really basic blocks. 14938297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) { 1494f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(PN.getType() == PN.getIncomingValue(i)->getType(), 1495023421e6892b2ba6dcd2bbee117e0bfb24545cf7whesse@chromium.org "PHI node operands are not the same type as the result!", &PN); 14968297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org } 14978297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org 14988297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org // All other PHI node constraints are checked in the visitBasicBlock method. 14998297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org 15008297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org visitInstruction(PN); 15018297530cd2b71ba1a2fe6f27ba1c030a20468306machenbach@chromium.org} 1502528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org 1503a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.orgvoid Verifier::VerifyCallSite(CallSite CS) { 1504a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Instruction *I = CS.getInstruction(); 150532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 15063a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(CS.getCalledValue()->getType()->isPointerTy(), 15073a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "Called function must be a pointer!", I); 15083a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType()); 1509dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 1510a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(FPTy->getElementType()->isFunctionTy(), 1511ec6855e761a7474a580d750a45d748323dd3b7c7verwaest@chromium.org "Called function is not pointer to function type!", I); 1512ec6855e761a7474a580d750a45d748323dd3b7c7verwaest@chromium.org FunctionType *FTy = cast<FunctionType>(FPTy->getElementType()); 1513ec6855e761a7474a580d750a45d748323dd3b7c7verwaest@chromium.org 1514a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Verify that the correct number of arguments are being passed 1515528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org if (FTy->isVarArg()) 1516528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(CS.arg_size() >= FTy->getNumParams(), 1517528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "Called function requires more parameters than were provided!",I); 1518528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org else 1519528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert1(CS.arg_size() == FTy->getNumParams(), 1520a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org "Incorrect number of arguments passed to called function!", I); 1521a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org 1522a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org // Verify that all arguments to the call match the function type. 1523f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) 1524528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org Assert3(CS.getArgument(i)->getType() == FTy->getParamType(i), 1525528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org "Call parameter type does not match function signature!", 1526a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org CS.getArgument(i), FTy->getParamType(i), I); 1527a3b66334e4dd35d9d4874d275ef9c4a756f0225cmachenbach@chromium.org 1528528ce02b8680a3ab6d75c7079f180a4016c69b7amachenbach@chromium.org AttributeSet Attrs = CS.getAttributes(); 1529a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1530a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(VerifyAttributeCount(Attrs, CS.arg_size()), 1531a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Attribute after last parameter!", I); 153232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1533d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Verify call attributes. 1534d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org VerifyFunctionAttrs(FTy, Attrs, I); 1535d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1536d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (FTy->isVarArg()) { 1537d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // FIXME? is 'nest' even legal here? 153832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org bool SawNest = false; 1539d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org bool SawReturned = false; 1540d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1541d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) { 1542d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Nest)) 1543d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org SawNest = true; 1544d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Returned)) 154532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org SawReturned = true; 1546d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 1547d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1548d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Check attributes on the varargs part. 1549d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { 1550d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Type *Ty = CS.getArgument(Idx-1)->getType(); 1551d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org VerifyParameterAttrs(Attrs, Idx, Ty, false, I); 1552d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 155332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Nest)) { 1554d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(!SawNest, "More than one parameter has attribute nest!", I); 1555d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org SawNest = true; 1556d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 155732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1558a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Attrs.hasAttribute(Idx, Attribute::Returned)) { 15598e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(!SawReturned, "More than one parameter has attribute returned!", 15608e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org I); 1561a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(Ty->canLosslesslyBitCastTo(FTy->getReturnType()), 156232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "Incompatible argument and return types for 'returned' " 1563c8cbc43a1fd5fda5d6a1e172f720cbd1215157c8machenbach@chromium.org "attribute", I); 1564c8cbc43a1fd5fda5d6a1e172f720cbd1215157c8machenbach@chromium.org SawReturned = true; 15653a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org } 15663a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 15673a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(!Attrs.hasAttribute(Idx, Attribute::StructRet), 1568f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Attribute 'sret' cannot be used for vararg call arguments!", I); 15696d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org } 1570f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org } 1571f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 1572f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Verify that there's no metadata unless it's a direct call to an intrinsic. 15736d786c9805481bd13ecb29c3155540f2f32950e1svenpanne@chromium.org if (CS.getCalledFunction() == 0 || 1574dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org !CS.getCalledFunction()->getName().startswith("llvm.")) { 1575d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org for (FunctionType::param_iterator PI = FTy->param_begin(), 1576d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org PE = FTy->param_end(); PI != PE; ++PI) 15778e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org Assert1(!(*PI)->isMetadataTy(), 1578d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Function has metadata parameter but isn't an intrinsic", I); 1579d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 1580d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1581d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org visitInstruction(*I); 1582a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1583a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1584a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitCallInst(CallInst &CI) { 1585c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org VerifyCallSite(&CI); 1586c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org 1587db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org if (Function *F = CI.getCalledFunction()) 1588db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) 1589c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org visitIntrinsicFunctionCall(ID, CI); 1590c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org} 1591c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org 1592c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.orgvoid Verifier::visitInvokeInst(InvokeInst &II) { 1593c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org VerifyCallSite(&II); 1594db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org 1595db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org // Verify that there is a landingpad instruction as the first non-PHI 1596c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org // instruction of the 'unwind' destination. 1597c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org Assert1(II.getUnwindDest()->isLandingPad(), 1598c3669763e2617aefdac84a072327b201b3dff129jkummerow@chromium.org "The unwind destination does not have a landingpad instruction!",&II); 159932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1600a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitTerminatorInst(II); 1601d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org} 1602d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1603a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// visitBinaryOperator - Check that both arguments to the binary operator are 1604a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// of the same type! 1605a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// 1606c54d36599f1e72bddd09d5b7a980304c7b638048ricow@chromium.orgvoid Verifier::visitBinaryOperator(BinaryOperator &B) { 1607c54d36599f1e72bddd09d5b7a980304c7b638048ricow@chromium.org Assert1(B.getOperand(0)->getType() == B.getOperand(1)->getType(), 1608c54d36599f1e72bddd09d5b7a980304c7b638048ricow@chromium.org "Both operands to a binary operator are not of the same type!", &B); 1609c54d36599f1e72bddd09d5b7a980304c7b638048ricow@chromium.org 1610c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org switch (B.getOpcode()) { 1611f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // Check that integer arithmetic operators are only used with 1612a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // integral operands. 1613a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org case Instruction::Add: 1614a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org case Instruction::Sub: 161532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org case Instruction::Mul: 1616d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case Instruction::SDiv: 1617d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org case Instruction::UDiv: 1618d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case Instruction::SRem: 161932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org case Instruction::URem: 1620d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org Assert1(B.getType()->isIntOrIntVectorTy(), 1621d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org "Integer arithmetic operators only work with integral types!", &B); 1622d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org Assert1(B.getType() == B.getOperand(0)->getType(), 1623d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org "Integer arithmetic operators must have same type " 1624d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "for operands and result!", &B); 1625d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org break; 1626d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Check that floating-point arithmetic operators are only used with 1627d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org // floating-point operands. 1628d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case Instruction::FAdd: 1629d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case Instruction::FSub: 163032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org case Instruction::FMul: 1631c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org case Instruction::FDiv: 16329af454f6b1c6a921ac79ba0b9a979c73adb2ca1emachenbach@chromium.org case Instruction::FRem: 16339af454f6b1c6a921ac79ba0b9a979c73adb2ca1emachenbach@chromium.org Assert1(B.getType()->isFPOrFPVectorTy(), 1634c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org "Floating-point arithmetic operators only work with " 1635f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "floating-point types!", &B); 1636c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org Assert1(B.getType() == B.getOperand(0)->getType(), 163732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "Floating-point arithmetic operators must have same type " 1638c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org "for operands and result!", &B); 1639c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org break; 1640c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org // Check that logical operators are only used with integral operands. 1641f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org case Instruction::And: 16424cd70b470729dd5850dd4120a350f01363d16837yangguo@chromium.org case Instruction::Or: 1643c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org case Instruction::Xor: 1644d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(B.getType()->isIntOrIntVectorTy(), 1645d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Logical operators only work with integral types!", &B); 1646d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(B.getType() == B.getOperand(0)->getType(), 1647d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Logical operators must have same type for operands and result!", 1648d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org &B); 1649d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org break; 1650c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org case Instruction::Shl: 1651c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org case Instruction::LShr: 1652c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org case Instruction::AShr: 165332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(B.getType()->isIntOrIntVectorTy(), 1654a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Shifts only work with integral types!", &B); 1655a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(B.getType() == B.getOperand(0)->getType(), 16568f806e8b8f108ca2c8899c5d31861ef1273dcd4akarlklose@chromium.org "Shift return type must be same as operands!", &B); 1657fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org break; 1658c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org default: 1659c3b670ff19220959730d7886892bc4beb95d2ebaerik.corry@gmail.com llvm_unreachable("Unknown BinaryOperator opcode!"); 166053ad17558c81e6099cef4442237d7da643a5becfsvenpanne@chromium.org } 166153ad17558c81e6099cef4442237d7da643a5becfsvenpanne@chromium.org 1662c3b670ff19220959730d7886892bc4beb95d2ebaerik.corry@gmail.com visitInstruction(B); 1663a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1664a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1665381adef828187e237e8758ab730dee1c2834a0b3machenbach@chromium.orgvoid Verifier::visitICmpInst(ICmpInst &IC) { 1666ed1a63112185152bc10fbd02418393804a5fcf04machenbach@chromium.org // Check that the operands are the same type 1667662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org Type *Op0Ty = IC.getOperand(0)->getType(); 1668662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org Type *Op1Ty = IC.getOperand(1)->getType(); 1669662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org Assert1(Op0Ty == Op1Ty, 1670fb732b17922ea75830be4db6b80534c4827d8a55jkummerow@chromium.org "Both operands to ICmp instruction are not of the same type!", &IC); 1671a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org // Check that the operands are the right type 167232d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org Assert1(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(), 167332d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org "Invalid operand types for ICmp instruction", &IC); 167432d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org // Check that the predicate is valid. 1675f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org Assert1(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE && 167632d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE, 1677a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Invalid predicate in ICmp instruction!", &IC); 1678a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1679c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org visitInstruction(IC); 1680c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org} 1681c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.org 1682c00ec2b94bc5505fa81f81daefd956f5a8776a09danno@chromium.orgvoid Verifier::visitFCmpInst(FCmpInst &FC) { 168332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Check that the operands are the same type 168432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Type *Op0Ty = FC.getOperand(0)->getType(); 1685a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Type *Op1Ty = FC.getOperand(1)->getType(); 1686c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org Assert1(Op0Ty == Op1Ty, 1687c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org "Both operands to FCmp instruction are not of the same type!", &FC); 1688f2038fb01417bcf7698b87a5dfaa4a861539618aerik.corry@gmail.com // Check that the operands are the right type 1689f2038fb01417bcf7698b87a5dfaa4a861539618aerik.corry@gmail.com Assert1(Op0Ty->isFPOrFPVectorTy(), 1690f2038fb01417bcf7698b87a5dfaa4a861539618aerik.corry@gmail.com "Invalid operand types for FCmp instruction", &FC); 169132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Check that the predicate is valid. 1692c3b670ff19220959730d7886892bc4beb95d2ebaerik.corry@gmail.com Assert1(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE && 1693a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE, 1694a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Invalid predicate in FCmp instruction!", &FC); 169532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1696ddd545c4c343dcf4331b9d80d2a0bdfa373a4a0fricow@chromium.org visitInstruction(FC); 1697f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org} 1698a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1699dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.orgvoid Verifier::visitExtractElementInst(ExtractElementInst &EI) { 1700a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(ExtractElementInst::isValidOperands(EI.getOperand(0), 1701a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org EI.getOperand(1)), 170232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "Invalid extractelement operands!", &EI); 1703c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org visitInstruction(EI); 1704c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org} 170532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1706c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.orgvoid Verifier::visitInsertElementInst(InsertElementInst &IE) { 1707c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org Assert1(InsertElementInst::isValidOperands(IE.getOperand(0), 1708a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org IE.getOperand(1), 1709a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org IE.getOperand(2)), 1710a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Invalid insertelement operands!", &IE); 171132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org visitInstruction(IE); 1712c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org} 1713d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1714c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.orgvoid Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { 171532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1), 171684bcc559ac20fb04f806e97d28a314b20b58fd60svenpanne@chromium.org SV.getOperand(2)), 1717c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org "Invalid shufflevector operands!", &SV); 1718c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org visitInstruction(SV); 1719c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org} 1720c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org 1721c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.orgvoid Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { 172232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Type *TargetTy = GEP.getPointerOperandType()->getScalarType(); 1723c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org 1724c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org Assert1(isa<PointerType>(TargetTy), 1725d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "GEP base pointer is not a vector or a vector of pointers", &GEP); 1726d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(cast<PointerType>(TargetTy)->getElementType()->isSized(), 1727d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "GEP into unsized type!", &GEP); 1728d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(GEP.getPointerOperandType()->isVectorTy() == 1729d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org GEP.getType()->isVectorTy(), "Vector GEP must return a vector value", 1730d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org &GEP); 1731d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 173232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end()); 1733c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org Type *ElTy = 1734c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org GetElementPtrInst::getIndexedType(GEP.getPointerOperandType(), Idxs); 1735c53e10d01c5495df3896b9d318910b58688c6929kmillikin@chromium.org Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP); 1736ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1737ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert2(GEP.getType()->getScalarType()->isPointerTy() && 1738ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org cast<PointerType>(GEP.getType()->getScalarType())->getElementType() 1739ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org == ElTy, "GEP is not of right type for indices!", &GEP, ElTy); 1740ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1741ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org if (GEP.getPointerOperandType()->isVectorTy()) { 1742ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org // Additional checks for vector GEPs. 1743ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org unsigned GepWidth = GEP.getPointerOperandType()->getVectorNumElements(); 1744ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(GepWidth == GEP.getType()->getVectorNumElements(), 1745ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Vector GEP result width doesn't match operand's", &GEP); 1746ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org for (unsigned i = 0, e = Idxs.size(); i != e; ++i) { 1747ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Type *IndexTy = Idxs[i]->getType(); 1748ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(IndexTy->isVectorTy(), 1749ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Vector GEP must have vector indices!", &GEP); 1750ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org unsigned IndexWidth = IndexTy->getVectorNumElements(); 1751ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(IndexWidth == GepWidth, "Invalid GEP index vector width", &GEP); 1752ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } 1753ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } 1754ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org visitInstruction(GEP); 1755ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org} 1756ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1757ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.orgstatic bool isContiguous(const ConstantRange &A, const ConstantRange &B) { 1758ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); 1759ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org} 1760ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1761ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.orgvoid Verifier::visitLoadInst(LoadInst &LI) { 1762ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType()); 1763ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(PTy, "Load operand must be a pointer.", &LI); 1764ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Type *ElTy = PTy->getElementType(); 1765ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert2(ElTy == LI.getType(), 1766ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Load result type does not match pointer operand type!", &LI, ElTy); 1767ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org if (LI.isAtomic()) { 1768ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease, 1769ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Load cannot have Release ordering", &LI); 1770ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(LI.getAlignment() != 0, 1771ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Atomic load must specify explicit alignment", &LI); 1772ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org if (!ElTy->isPointerTy()) { 1773ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert2(ElTy->isIntegerTy(), 1774ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "atomic store operand must have integer type!", 1775ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org &LI, ElTy); 1776ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org unsigned Size = ElTy->getPrimitiveSizeInBits(); 1777ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert2(Size >= 8 && !(Size & (Size - 1)), 1778ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "atomic store operand must be power-of-two byte-sized integer", 1779ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org &LI, ElTy); 1780ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } 1781ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } else { 1782ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(LI.getSynchScope() == CrossThread, 1783ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org "Non-atomic load cannot have SynchronizationScope specified", &LI); 1784ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org } 1785ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1786ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org if (MDNode *Range = LI.getMetadata(LLVMContext::MD_range)) { 1787ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org unsigned NumOperands = Range->getNumOperands(); 1788ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(NumOperands % 2 == 0, "Unfinished range!", Range); 1789ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org unsigned NumRanges = NumOperands / 2; 1790ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org Assert1(NumRanges >= 1, "It should have at least one range!", Range); 1791ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org 1792ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org ConstantRange LastRange(1); // Dummy initial value 1793ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org for (unsigned i = 0; i < NumRanges; ++i) { 1794ca2f2040e0e1a10df95bec18e69499f85f4c1316machenbach@chromium.org ConstantInt *Low = dyn_cast<ConstantInt>(Range->getOperand(2*i)); 1795fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(Low, "The lower limit must be an integer!", Low); 1796fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org ConstantInt *High = dyn_cast<ConstantInt>(Range->getOperand(2*i + 1)); 1797fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(High, "The upper limit must be an integer!", High); 1798fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(High->getType() == Low->getType() && 1799fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org High->getType() == ElTy, "Range types must match load type!", 1800fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org &LI); 180132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1802a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org APInt HighV = High->getValue(); 1803fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org APInt LowV = Low->getValue(); 1804fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org ConstantRange CurRange(LowV, HighV); 1805fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(!CurRange.isEmptySet() && !CurRange.isFullSet(), 1806fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org "Range must not be empty!", Range); 1807a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (i != 0) { 1808a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(CurRange.intersectWith(LastRange).isEmptySet(), 18097028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org "Intervals are overlapping", Range); 18107028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org Assert1(LowV.sgt(LastRange.getLower()), "Intervals are not in order", 1811fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Range); 1812486536df718553960f9700559e80e5b10b0d5994dslomov@chromium.org Assert1(!isContiguous(CurRange, LastRange), "Intervals are contiguous", 1813486536df718553960f9700559e80e5b10b0d5994dslomov@chromium.org Range); 181432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org } 1815a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org LastRange = ConstantRange(LowV, HighV); 1816f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org } 1817a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (NumRanges > 2) { 1818471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org APInt FirstLow = 1819471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org dyn_cast<ConstantInt>(Range->getOperand(0))->getValue(); 1820471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org APInt FirstHigh = 1821a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org dyn_cast<ConstantInt>(Range->getOperand(1))->getValue(); 1822a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org ConstantRange FirstRange(FirstLow, FirstHigh); 1823a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(FirstRange.intersectWith(LastRange).isEmptySet(), 1824a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Intervals are overlapping", Range); 1825a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!isContiguous(FirstRange, LastRange), "Intervals are contiguous", 1826a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Range); 1827a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 1828a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1829a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1830a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 1831a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1832a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(LI); 1833a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1834a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1835a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitStoreInst(StoreInst &SI) { 1836a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType()); 1837a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(PTy, "Store operand must be a pointer.", &SI); 1838a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Type *ElTy = PTy->getElementType(); 1839a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert2(ElTy == SI.getOperand(0)->getType(), 1840d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Stored value type does not match pointer operand type!", 1841d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org &SI, ElTy); 1842d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org if (SI.isAtomic()) { 1843d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease, 1844d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Store cannot have Acquire ordering", &SI); 1845d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(SI.getAlignment() != 0, 1846f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Atomic store must specify explicit alignment", &SI); 184732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org if (!ElTy->isPointerTy()) { 184832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert2(ElTy->isIntegerTy(), 184932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "atomic store operand must have integer type!", 18503a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org &SI, ElTy); 185132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org unsigned Size = ElTy->getPrimitiveSizeInBits(); 185232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert2(Size >= 8 && !(Size & (Size - 1)), 18533a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "atomic store operand must be power-of-two byte-sized integer", 18543a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org &SI, ElTy); 1855a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 1856e27d617298263725e8a48c2aa14029759b952623mstarzinger@chromium.org } else { 1857fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org Assert1(SI.getSynchScope() == CrossThread, 1858fb37721ea34922d8758d5cb26ae465aaf241e6b6yangguo@chromium.org "Non-atomic store cannot have SynchronizationScope specified", &SI); 1859662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org } 1860662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org visitInstruction(SI); 1861662436e7b124b3535773535c671c53db322070b5verwaest@chromium.org} 1862dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org 1863a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitAllocaInst(AllocaInst &AI) { 1864a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org PointerType *PTy = AI.getType(); 186532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(PTy->getAddressSpace() == 0, 1866d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Allocation instruction pointer not in the generic address space!", 1867d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org &AI); 1868a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(PTy->getElementType()->isSized(), "Cannot allocate unsized type", 1869a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org &AI); 1870a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(AI.getArraySize()->getType()->isIntegerTy(), 187132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org "Alloca array size must have integer type", &AI); 1872a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(AI); 1873a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 1874a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1875a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) { 1876a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(CXI.getOrdering() != NotAtomic, 1877a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "cmpxchg instructions must be atomic.", &CXI); 18787028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org Assert1(CXI.getOrdering() != Unordered, 1879a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "cmpxchg instructions cannot be unordered.", &CXI); 18807028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType()); 1881a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(PTy, "First cmpxchg operand must be a pointer.", &CXI); 1882a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Type *ElTy = PTy->getElementType(); 1883a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert2(ElTy->isIntegerTy(), 1884a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "cmpxchg operand must have integer type!", 1885a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org &CXI, ElTy); 1886a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org unsigned Size = ElTy->getPrimitiveSizeInBits(); 1887a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org Assert2(Size >= 8 && !(Size & (Size - 1)), 1888a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org "cmpxchg operand must be power-of-two byte-sized integer", 1889a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org &CXI, ElTy); 1890a53e8e03bcb23716d1025de362626f90f00da892svenpanne@chromium.org Assert2(ElTy == CXI.getOperand(1)->getType(), 1891471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org "Expected value type does not match pointer operand type!", 1892a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org &CXI, ElTy); 1893a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert2(ElTy == CXI.getOperand(2)->getType(), 1894a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Stored value type does not match pointer operand type!", 18957028c05c1c71b9d5c5fe1bca01f2461d17a2dda7mmassi@chromium.org &CXI, ElTy); 1896486536df718553960f9700559e80e5b10b0d5994dslomov@chromium.org visitInstruction(CXI); 1897486536df718553960f9700559e80e5b10b0d5994dslomov@chromium.org} 1898d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 1899d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.orgvoid Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) { 1900d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(RMWI.getOrdering() != NotAtomic, 1901d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "atomicrmw instructions must be atomic.", &RMWI); 1902d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(RMWI.getOrdering() != Unordered, 1903d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "atomicrmw instructions cannot be unordered.", &RMWI); 1904d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType()); 190532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(PTy, "First atomicrmw operand must be a pointer.", &RMWI); 1906d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Type *ElTy = PTy->getElementType(); 1907d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert2(ElTy->isIntegerTy(), 1908d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "atomicrmw operand must have integer type!", 190971f9fca5cfb606009211e0631f33b76cc2ddce3cbmeurer@chromium.org &RMWI, ElTy); 1910d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org unsigned Size = ElTy->getPrimitiveSizeInBits(); 1911f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert2(Size >= 8 && !(Size & (Size - 1)), 1912f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "atomicrmw operand must be power-of-two byte-sized integer", 1913d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org &RMWI, ElTy); 1914d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert2(ElTy == RMWI.getOperand(1)->getType(), 1915d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Argument value type does not match pointer operand type!", 1916d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org &RMWI, ElTy); 1917d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() && 191832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP, 1919d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Invalid binary operation!", &RMWI); 1920d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org visitInstruction(RMWI); 1921d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org} 1922f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org 1923d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.orgvoid Verifier::visitFenceInst(FenceInst &FI) { 1924d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org const AtomicOrdering Ordering = FI.getOrdering(); 1925d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(Ordering == Acquire || Ordering == Release || 1926d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Ordering == AcquireRelease || Ordering == SequentiallyConsistent, 1927d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "fence instructions may only have " 1928d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "acquire, release, acq_rel, or seq_cst ordering.", &FI); 1929d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org visitInstruction(FI); 1930d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org} 1931d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 1932d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.orgvoid Verifier::visitExtractValueInst(ExtractValueInst &EVI) { 1933d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(), 1934d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org EVI.getIndices()) == 1935d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org EVI.getType(), 193671f9fca5cfb606009211e0631f33b76cc2ddce3cbmeurer@chromium.org "Invalid ExtractValueInst operands!", &EVI); 193771f9fca5cfb606009211e0631f33b76cc2ddce3cbmeurer@chromium.org 193871f9fca5cfb606009211e0631f33b76cc2ddce3cbmeurer@chromium.org visitInstruction(EVI); 1939d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org} 1940d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org 1941d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.orgvoid Verifier::visitInsertValueInst(InsertValueInst &IVI) { 1942d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org Assert1(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(), 1943d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org IVI.getIndices()) == 1944d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org IVI.getOperand(1)->getType(), 1945d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org "Invalid InsertValueInst operands!", &IVI); 1946a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 1947a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org visitInstruction(IVI); 1948a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 194932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1950a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::visitLandingPadInst(LandingPadInst &LPI) { 195104921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org BasicBlock *BB = LPI.getParent(); 195204921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org 195304921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // The landingpad instruction is ill-formed if it doesn't have any clauses and 195404921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // isn't a cleanup. 195504921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org Assert1(LPI.getNumClauses() > 0 || LPI.isCleanup(), 19568e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org "LandingPadInst needs at least one clause or to be a cleanup.", &LPI); 1957ddda9e81d3175130f2029c0e1205d265a00c32edjkummerow@chromium.org 1958ddda9e81d3175130f2029c0e1205d265a00c32edjkummerow@chromium.org // The landingpad instruction defines its parent as a landing pad block. The 1959a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // landing pad block may be branched to only by the unwind edge of an invoke. 196032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) { 1961ddda9e81d3175130f2029c0e1205d265a00c32edjkummerow@chromium.org const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator()); 19623a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(II && II->getUnwindDest() == BB && II->getNormalDest() != BB, 19633a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "Block containing LandingPadInst must be jumped to " 196404921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org "only by the unwind edge of an invoke.", &LPI); 196504921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org } 196604921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org 196704921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // The landingpad instruction must be the first non-PHI instruction in the 19687c3372bc426136cb79479c1b59d1770f5528882ahpayer@chromium.org // block. 196904921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org Assert1(LPI.getParent()->getLandingPadInst() == &LPI, 197004921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org "LandingPadInst not the first non-PHI instruction in the block.", 197104921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org &LPI); 197204921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org 197304921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // The personality functions for all landingpad instructions within the same 197404921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org // function should match. 1975dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org if (PersonalityFn) 197604921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org Assert1(LPI.getPersonalityFn() == PersonalityFn, 197704921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org "Personality function doesn't match others in function", &LPI); 1978d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org PersonalityFn = LPI.getPersonalityFn(); 1979d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 1980f5a24546072ecdbbd6372c85c42157e01e913561titzer@chromium.org // All operands must be constants. 1981d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(isa<Constant>(PersonalityFn), "Personality function is not constant!", 1982d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org &LPI); 198304921a8093ce8bbec34084bd742b7aa3d299be15ager@chromium.org for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) { 1984a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Value *Clause = LPI.getClause(i); 1985a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(isa<Constant>(Clause), "Clause is not constant!", &LPI); 1986a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (LPI.isCatch(i)) { 1987471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org Assert1(isa<PointerType>(Clause->getType()), 1988a03ba1e53fa6a04b8e56747536f226380bb6269bmachenbach@chromium.org "Catch operand does not have pointer type!", &LPI); 1989471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org } else { 1990de88679a78f9dae12fdf7955610969ac4c79b0bemstarzinger@chromium.org Assert1(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI); 1991471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org Assert1(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause), 1992471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org "Filter operand is not an array of constants!", &LPI); 1993471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org } 1994471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org } 1995b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org 1996b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org visitInstruction(LPI); 1997b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org} 199832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 1999a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.orgvoid Verifier::verifyDominatesUse(Instruction &I, unsigned i) { 2000d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Instruction *Op = cast<Instruction>(I.getOperand(i)); 2001d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // If the we have an invalid invoke, don't try to compute the dominance. 2002f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org // We already reject it in the invoke specific checks and the dominance 2003d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // computation doesn't handle multiple edges. 2004d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) { 2005d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (II->getNormalDest() == II->getUnwindDest()) 2006d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org return; 2007d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 2008e31286d471eb2e656a1809383fa16b76053dd673machenbach@chromium.org 2009f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org const Use &U = I.getOperandUse(i); 2010f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, U), 2011e31286d471eb2e656a1809383fa16b76053dd673machenbach@chromium.org "Instruction does not dominate all uses!", Op, &I); 2012a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org} 2013a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2014d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org/// verifyInstruction - Verify that an instruction is well formed. 2015d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org/// 2016d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.orgvoid Verifier::visitInstruction(Instruction &I) { 2017f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org BasicBlock *BB = I.getParent(); 2018a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(BB, "Instruction not embedded in basic block!", &I); 2019a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2020659ceec4628056d3c6e7076c850fba1c412cbb8ayangguo@chromium.org if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential 202156c14afabc547f0a8ab2e24d789c00030f8df892ulan@chromium.org for (Value::use_iterator UI = I.use_begin(), UE = I.use_end(); 202256c14afabc547f0a8ab2e24d789c00030f8df892ulan@chromium.org UI != UE; ++UI) 2023a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(*UI != (User*)&I || !DT->isReachableFromEntry(BB), 2024471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org "Only PHI nodes may reference their own value!", &I); 2025f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org } 2026a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 202732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Check that void typed values don't have names 20283a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(!I.getType()->isVoidTy() || !I.hasName(), 20293a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "Instruction has a name, but provides a void value!", &I); 20303a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 203128faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org // Check that the return value of the instruction is either void or a legal 2032b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org // value type. 20338c0a43f09f145d9fc6f969d559873018176eeb6adanno@chromium.org Assert1(I.getType()->isVoidTy() || 2034dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org I.getType()->isFirstClassType(), 2035a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Instruction returns a non-scalar type!", &I); 2036a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2037f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org // Check that the instruction doesn't produce metadata. Calls are already 2038f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org // checked against the callee type. 2039d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert1(!I.getType()->isMetadataTy() || 2040d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org isa<CallInst>(I) || isa<InvokeInst>(I), 2041d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org "Invalid use of metadata!", &I); 2042d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 2043d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Check that all uses of the instruction, if they are instructions 2044d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // themselves, actually have parent basic blocks. If the use is not an 2045f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org // instruction, it is an error! 2046f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org for (User::use_iterator UI = I.use_begin(), UE = I.use_end(); 2047d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org UI != UE; ++UI) { 2048d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org if (Instruction *Used = dyn_cast<Instruction>(*UI)) 2049d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Assert2(Used->getParent() != 0, "Instruction referencing instruction not" 2050d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org " embedded in a basic block!", &I, Used); 2051d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org else { 2052d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org CheckFailed("Use of instruction is not an instruction!", *UI); 2053d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org return; 2054d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 2055d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org } 2056f2f0489407bbb5e50d16ae791442df29513b53b5machenbach@chromium.org 2057a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 2058659ceec4628056d3c6e7076c850fba1c412cbb8ayangguo@chromium.org Assert1(I.getOperand(i) != 0, "Instruction has null operand!", &I); 205956c14afabc547f0a8ab2e24d789c00030f8df892ulan@chromium.org 2060a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Check to make sure that only first-class-values are operands to 2061471f2f1d24adb4bad1edc3bf0ee35092486de187mstarzinger@chromium.org // instructions. 206228faa982749c4aa9c090939453dea14bb118f613jkummerow@chromium.org if (!I.getOperand(i)->getType()->isFirstClassType()) { 2063b752d4061aaeb7d6a6ec368607871789d54b0207dslomov@chromium.org Assert1(0, "Instruction operands must be first-class values!", &I); 2064d4be0f0c0edfc0a0b46e745055c3dc497c0ffcb5verwaest@chromium.org } 2065a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2066a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (Function *F = dyn_cast<Function>(I.getOperand(i))) { 2067a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org // Check to make sure that the "address of" an intrinsic function is never 206832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // taken. 2069a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!F->isIntrinsic() || i == (isa<CallInst>(I) ? e-1 : 0), 2070d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "Cannot take the address of an intrinsic!", &I); 2071d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(!F->isIntrinsic() || isa<CallInst>(I) || 2072d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org F->getIntrinsicID() == Intrinsic::donothing, 2073d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "Cannot invoke an intrinsinc other than donothing", &I); 2074a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(F->getParent() == Mod, "Referencing function in another module!", 207532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org &I); 20763a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) { 20773a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org Assert1(OpBB->getParent() == BB->getParent(), 20783a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "Referring to a basic block in another function!", &I); 2079d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) { 2080d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org Assert1(OpArg->getParent() == BB->getParent(), 2081d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org "Referring to an argument in another function!", &I); 2082d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) { 2083dcebac0f4c6c0da579b7cc91a0cbba8f3c820c8dricow@chromium.org Assert1(GV->getParent() == Mod, "Referencing global in another module!", 2084d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org &I); 2085d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org } else if (isa<Instruction>(I.getOperand(i))) { 2086d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org verifyDominatesUse(I, i); 2087d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org } else if (isa<InlineAsm>(I.getOperand(i))) { 2088a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1((i + 1 == e && isa<CallInst>(I)) || 2089a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org (i + 3 == e && isa<InvokeInst>(I)), 2090a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Cannot take the address of an inline asm!", &I); 2091011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) { 2092a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (CE->getType()->isPtrOrPtrVectorTy()) { 20938d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org // If we have a ConstantExpr pointer, we need to see if it came from an 20948d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org // illegal bitcast (inttoptr <constant int> ) 20958d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org SmallVector<const ConstantExpr *, 4> Stack; 20968d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org SmallPtrSet<const ConstantExpr *, 4> Visited; 20978d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Stack.push_back(CE); 20988d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org 20998d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org while (!Stack.empty()) { 21008d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org const ConstantExpr *V = Stack.pop_back_val(); 21018d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org if (!Visited.insert(V)) 21028d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org continue; 21038d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org 21048d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org VerifyConstantExprBitcastType(V); 21058d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org 21068d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org for (unsigned I = 0, N = V->getNumOperands(); I != N; ++I) { 21078d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org if (ConstantExpr *Op = dyn_cast<ConstantExpr>(V->getOperand(I))) 21088d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Stack.push_back(Op); 21098d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } 21108d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } 21118d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } 21128d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } 21138d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } 21148d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org 21158d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) { 21168d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Assert1(I.getType()->isFPOrFPVectorTy(), 21178d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org "fpmath requires a floating point result!", &I); 21188d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Assert1(MD->getNumOperands() == 1, "fpmath takes one operand!", &I); 21198d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Value *Op0 = MD->getOperand(0); 21208d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org if (ConstantFP *CFP0 = dyn_cast_or_null<ConstantFP>(Op0)) { 21218d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org APFloat Accuracy = CFP0->getValueAPF(); 21228d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org Assert1(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(), 21238d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org "fpmath accuracy not a positive number!", &I); 21248d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org } else { 2125a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(false, "invalid fpmath accuracy!", &I); 212632cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org } 2127a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org } 2128a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2129a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org MDNode *MD = I.getMetadata(LLVMContext::MD_range); 2130011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org Assert1(!MD || isa<LoadInst>(I), "Ranges are only for loads!", &I); 2131011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org 2132a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org if (!DisableDebugInfoVerifier) { 2133f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org MD = I.getMetadata(LLVMContext::MD_dbg); 2134f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Finder.processLocation(*Mod, DILocation(MD)); 2135f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org } 2136011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org 2137011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org InstsInThisBlock.insert(&I); 2138011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org} 2139011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org 21408d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org/// VerifyIntrinsicType - Verify that the specified type (which comes from an 2141011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org/// intrinsic argument or return value) matches the type constraints specified 2142011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org/// by the .td file (e.g. an "any integer" argument really is an integer). 2143011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org/// 2144011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org/// This return true on error but does not print a message. 2145011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.orgbool Verifier::VerifyIntrinsicType(Type *Ty, 2146011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org ArrayRef<Intrinsic::IITDescriptor> &Infos, 2147011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org SmallVectorImpl<Type*> &ArgTys) { 2148d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org using namespace Intrinsic; 2149d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 21508d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org // If we ran out of descriptors, there are too many arguments. 21518d8413cae4e7eb777aaed22e2901c19f8d5d1297machenbach@chromium.org if (Infos.empty()) return true; 2152d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org IITDescriptor D = Infos.front(); 2153d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Infos = Infos.slice(1); 2154011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org 2155011a81ffd5df0e081e7c00ef430b2fec5079bf2amachenbach@chromium.org switch (D.Kind) { 2156a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org case IITDescriptor::Void: return !Ty->isVoidTy(); 2157a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org case IITDescriptor::VarArg: return true; 2158a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); 215932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org case IITDescriptor::Metadata: return !Ty->isMetadataTy(); 2160d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case IITDescriptor::Half: return !Ty->isHalfTy(); 2161db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org case IITDescriptor::Float: return !Ty->isFloatTy(); 2162d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case IITDescriptor::Double: return !Ty->isDoubleTy(); 216332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width); 2164d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case IITDescriptor::Vector: { 2165d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org VectorType *VT = dyn_cast<VectorType>(Ty); 2166d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org return VT == 0 || VT->getNumElements() != D.Vector_Width || 2167d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org VerifyIntrinsicType(VT->getElementType(), Infos, ArgTys); 2168d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org } 2169d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org case IITDescriptor::Pointer: { 217032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org PointerType *PT = dyn_cast<PointerType>(Ty); 2171c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org return PT == 0 || PT->getAddressSpace() != D.Pointer_AddressSpace || 2172c1956679bbba3170352a8cc735e8218f9dbe6867jkummerow@chromium.org VerifyIntrinsicType(PT->getElementType(), Infos, ArgTys); 2173db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org } 2174db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org 2175db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org case IITDescriptor::Struct: { 2176db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org StructType *ST = dyn_cast<StructType>(Ty); 2177db783297aea0c1b0faf438598202d2abe10da70ebmeurer@chromium.org if (ST == 0 || ST->getNumElements() != D.Struct_NumElements) 217832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org return true; 2179d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org 2180d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 2181d2be901879306d8ff27e78e37783028d581d46fcricow@chromium.org if (VerifyIntrinsicType(ST->getElementType(i), Infos, ArgTys)) 218232cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org return true; 218356454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org return false; 21848e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org } 21858e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 21868e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case IITDescriptor::Argument: 2187d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org // Two cases here - If this is the second occurrence of an argument, verify 218856454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org // that the later instance matches the previous instance. 218956454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org if (D.getArgumentNumber() < ArgTys.size()) 219056454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org return Ty != ArgTys[D.getArgumentNumber()]; 219156454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org 219256454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org // Otherwise, if this is the first instance of an argument, record it and 219356454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org // verify the "Any" kind. 219432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error"); 219556454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org ArgTys.push_back(Ty); 219656454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org 2197d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org switch (D.getArgumentKind()) { 219856454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy(); 21998e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy(); 22008e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty); 22018e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty); 22028e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org } 22038e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org llvm_unreachable("all argument kinds not covered"); 22048e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 22058e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org case IITDescriptor::ExtendVecArgument: 22068e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org // This may only be used when referring to a previous vector argument. 22078e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org return D.getArgumentNumber() >= ArgTys.size() || 22088e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org !isa<VectorType>(ArgTys[D.getArgumentNumber()]) || 220956454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org VectorType::getExtendedElementVectorType( 221056454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty; 221156454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org 221256454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org case IITDescriptor::TruncVecArgument: 221356454717593e7552d6846198b8e0f661fa36a3cayangguo@chromium.org // This may only be used when referring to a previous vector argument. 22143a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org return D.getArgumentNumber() >= ArgTys.size() || 221532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org !isa<VectorType>(ArgTys[D.getArgumentNumber()]) || 2216a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org VectorType::getTruncatedElementVectorType( 2217496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty; 22183a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org } 22193a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org llvm_unreachable("unhandled"); 22203a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org} 2221496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org 2222a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// \brief Verify if the intrinsic has variable arguments. 222332cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org/// This method is intended to be called after all the fixed arguments have been 222432cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org/// verified first. 222532cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org/// 2226a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org/// This method returns true on error and does not print an error message. 2227d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.orgbool 2228d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.orgVerifier::VerifyIntrinsicIsVarArg(bool isVarArg, 2229d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org ArrayRef<Intrinsic::IITDescriptor> &Infos) { 2230d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org using namespace Intrinsic; 2231d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org 2232d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org // If there are no descriptors left, then it can't be a vararg. 2233d8a3a149cb9dac7437e264a2fe50f680418c3a45jkummerow@chromium.org if (Infos.empty()) 2234496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org return isVarArg ? true : false; 2235496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org 2236496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org // There should be only one descriptor remaining at this point. 2237496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org if (Infos.size() != 1) 2238496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org return true; 2239496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org 224032cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org // Check and verify the descriptor. 2241496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org IITDescriptor D = Infos.front(); 2242496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org Infos = Infos.slice(1); 22433a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org if (D.Kind == IITDescriptor::VarArg) 2244496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org return isVarArg ? false : true; 2245a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2246496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org return true; 224732cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org} 224832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org 22493a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways. 2250496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org/// 2251496c03a64f12710e837204e261ef155601247895sgjesse@chromium.orgvoid Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { 2252f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Function *IF = CI.getCalledFunction(); 2253496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org Assert1(IF->isDeclaration(), "Intrinsic functions should never be defined!", 2254f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org IF); 2255496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org 2256496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org // Verify that the intrinsic prototype lines up with what the .td files 2257496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org // describe. 225832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org FunctionType *IFTy = IF->getFunctionType(); 2259496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org bool IsVarArg = IFTy->isVarArg(); 2260496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org 22613a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org SmallVector<Intrinsic::IITDescriptor, 8> Table; 2262496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org getIntrinsicInfoTableEntries(ID, Table); 2263496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org ArrayRef<Intrinsic::IITDescriptor> TableRef = Table; 2264a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org 2265a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org SmallVector<Type *, 4> ArgTys; 2266f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys), 2267a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Intrinsic has incorrect return type!", IF); 226832cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i) 226932cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org Assert1(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys), 22703a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org "Intrinsic has incorrect argument type!", IF); 22713a5fd78f0ca6c2827bb05f69a373d152a9ce6ff3fschneider@chromium.org 2272496c03a64f12710e837204e261ef155601247895sgjesse@chromium.org // Verify if the intrinsic call matches the vararg property. 2273f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org if (IsVarArg) 2274f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org Assert1(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 2275a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org "Intrinsic was not defined with variable arguments!", IF); 2276a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org else 2277a55512615f5adc085d23bc8589d155c4b579fb7bkasperl@chromium.org Assert1(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef), 227826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "Callsite was not defined with variable arguments!", IF); 227926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 228026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // All descriptors should be absorbed by now. 228126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(TableRef.empty(), "Intrinsic has too few arguments!", IF); 228226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 228326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // Now that we have the intrinsic ID and the actual argument types (and we 228426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // know they are legal for the intrinsic!) get the intrinsic name through the 228526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // usual means. This allows us to verify the mangling of argument types into 2286f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org // the name. 228726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(Intrinsic::getName(ID, ArgTys) == IF->getName(), 2288f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org "Intrinsic name not mangled correctly for type arguments!", IF); 228926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 229026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // If the intrinsic takes MDNode arguments, verify that they are either global 229126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // or are local to *this* function. 229226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (unsigned i = 0, e = CI.getNumArgOperands(); i != e; ++i) 229326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org if (MDNode *MD = dyn_cast<MDNode>(CI.getArgOperand(i))) 229426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org visitMDNode(*MD, CI.getParent()->getParent()); 229526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 229626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org switch (ID) { 229726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org default: 229826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 229926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::ctlz: // llvm.ctlz 230026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::cttz: // llvm.cttz 230126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(1)), 230226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "is_zero_undef argument of bit counting intrinsics must be a " 230326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "constant int", &CI); 230426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 230526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::dbg_declare: { // llvm.dbg.declare 230626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(CI.getArgOperand(0) && isa<MDNode>(CI.getArgOperand(0)), 230726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "invalid llvm.dbg.declare intrinsic call 1", &CI); 230826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org MDNode *MD = cast<MDNode>(CI.getArgOperand(0)); 230926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(MD->getNumOperands() == 1, 231026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "invalid llvm.dbg.declare intrinsic call 2", &CI); 231126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org if (!DisableDebugInfoVerifier) 231226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Finder.processDeclare(*Mod, cast<DbgDeclareInst>(&CI)); 231326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } break; 231426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::dbg_value: { //llvm.dbg.value 231526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org if (!DisableDebugInfoVerifier) { 231626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(CI.getArgOperand(0) && isa<MDNode>(CI.getArgOperand(0)), 231726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "invalid llvm.dbg.value intrinsic call 1", &CI); 231826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Finder.processValue(*Mod, cast<DbgValueInst>(&CI)); 231926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 232026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 232126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 232226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::memcpy: 232326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::memmove: 232426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::memset: 232526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(3)), 232693720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org "alignment argument of memory intrinsics must be a constant int", 2327196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org &CI); 232893720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(4)), 232926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "isvolatile argument of memory intrinsics must be a constant int", 233026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org &CI); 233126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 233226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::gcroot: 233326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::gcwrite: 233426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::gcread: 2335f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org if (ID == Intrinsic::gcroot) { 2336f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org AllocaInst *AI = 2337f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts()); 233826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI); 233926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<Constant>(CI.getArgOperand(1)), 234026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "llvm.gcroot parameter #2 must be a constant.", &CI); 234126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org if (!AI->getType()->getElementType()->isPointerTy()) { 234226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(!isa<ConstantPointerNull>(CI.getArgOperand(1)), 234326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "llvm.gcroot parameter #1 must either be a pointer alloca, " 234426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "or argument #2 must be a non-null constant.", &CI); 234526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 234626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 234726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 234893720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org Assert1(CI.getParent()->getParent()->hasGC(), 234926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "Enclosing function does not use GC.", &CI); 235026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 235126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::init_trampoline: 235226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()), 235326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "llvm.init_trampoline parameter #2 must resolve to a function.", 235426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org &CI); 235526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 235626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::prefetch: 235726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(1)) && 235826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org isa<ConstantInt>(CI.getArgOperand(2)) && 235926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 && 236026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4, 236126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "invalid arguments to llvm.prefetch", 236226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org &CI); 236326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 236426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::stackprotector: 236526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()), 236626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "llvm.stackprotector parameter #2 must resolve to an alloca.", 236793720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org &CI); 236826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 236926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::lifetime_start: 237026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::lifetime_end: 237126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::invariant_start: 237226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(0)), 237326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "size argument of memory use markers must be a constant integer", 237426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org &CI); 2375f15d0cdbef11a212e108432465f014a7d3c3aa12machenbach@chromium.org break; 237626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org case Intrinsic::invariant_end: 237726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(isa<ConstantInt>(CI.getArgOperand(1)), 237826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "llvm.invariant.end parameter #2 must be a constant integer", &CI); 237926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org break; 238026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 238193720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org} 2382196eb601290dc49c3754da728dc58700dff2de1bmachenbach@chromium.org 238326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.orgvoid Verifier::verifyDebugInfo() { 238426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org // Verify Debug Info. 238593720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org if (!DisableDebugInfoVerifier) { 238626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (DebugInfoFinder::iterator I = Finder.compile_unit_begin(), 238726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org E = Finder.compile_unit_end(); I != E; ++I) 238826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(DICompileUnit(*I).Verify(), "DICompileUnit does not Verify!", *I); 238926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (DebugInfoFinder::iterator I = Finder.subprogram_begin(), 239026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org E = Finder.subprogram_end(); I != E; ++I) 239126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(DISubprogram(*I).Verify(), "DISubprogram does not Verify!", *I); 239226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (DebugInfoFinder::iterator I = Finder.global_variable_begin(), 239326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org E = Finder.global_variable_end(); I != E; ++I) 239426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(DIGlobalVariable(*I).Verify(), 239526ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org "DIGlobalVariable does not Verify!", *I); 239626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (DebugInfoFinder::iterator I = Finder.type_begin(), 239726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org E = Finder.type_end(); I != E; ++I) 239826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(DIType(*I).Verify(), "DIType does not Verify!", *I); 239926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org for (DebugInfoFinder::iterator I = Finder.scope_begin(), 240026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org E = Finder.scope_end(); I != E; ++I) 240126ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org Assert1(DIScope(*I).Verify(), "DIScope does not Verify!", *I); 240226ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org } 240326ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org} 240426ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 240593720aaa16a789ba13d52a265a479b26f4885e2emachenbach@chromium.org//===----------------------------------------------------------------------===// 240626ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org// Implement the public interfaces to this file... 240726ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org//===----------------------------------------------------------------------===// 240826ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org 240926ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.orgFunctionPass *llvm::createVerifierPass(VerifierFailureAction action) { 241026ca35cc4ec47151d9c6d3890b0f052fc79cb8afmachenbach@chromium.org return new Verifier(action); 241132cb9b2c195baa85d4c04f4c7b22b9aa04e97d3fverwaest@chromium.org} 2412160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org 24138e36b5ba34174c8ceb04a47d7e10dcc8f43d94a4machenbach@chromium.org 2414d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org/// verifyFunction - Check a function for errors, printing messages on stderr. 2415fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org/// Return true if the function is corrupt. 2416fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org/// 2417fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.orgbool llvm::verifyFunction(const Function &f, VerifierFailureAction action) { 2418fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org Function &F = const_cast<Function&>(f); 2419fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org assert(!F.isDeclaration() && "Cannot verify external functions"); 2420fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org 242132d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org FunctionPassManager FPM(F.getParent()); 242232d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org Verifier *V = new Verifier(action); 2423ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org FPM.add(V); 2424ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org FPM.doInitialization(); 2425ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org FPM.run(F); 2426fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org return V->Broken; 2427fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org} 2428d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org 2429d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org/// verifyModule - Check a module for errors, printing messages on stderr. 2430d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org/// Return true if the module is corrupt. 2431d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org/// 2432d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.orgbool llvm::verifyModule(const Module &M, VerifierFailureAction action, 2433d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org std::string *ErrorInfo) { 2434d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org PassManager PM; 2435d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org Verifier *V = new Verifier(action); 2436d3c42109e5b85232d19beab8deeb24bdcbbf07f9danno@chromium.org PM.add(V); 2437160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org PM.run(const_cast<Module&>(M)); 2438160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org 2439fb0463312815affb1f0e9d5e351b7f9a3422e3a2svenpanne@chromium.org if (ErrorInfo && V->Broken) 244032d7dbafe29be06cec1edd36c31fbe2865c799f4ulan@chromium.org *ErrorInfo = V->MessagesStr.str(); 2441160a7b0747492f3f735353d9582521f3314bf4dfdanno@chromium.org return V->Broken; 2442ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org} 2443ea9b8ba58955b7efcc3e1550dd33a44fb4530136hpayer@chromium.org