Lint.cpp revision 292fc87fe2f1611e7c83a61796ab71db6a0f7d97
1113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman//===-- Lint.cpp - Check for common errors in LLVM IR ---------------------===// 2113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 3113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// The LLVM Compiler Infrastructure 4113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 5113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// This file is distributed under the University of Illinois Open Source 6113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// License. See LICENSE.TXT for details. 7113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 8113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman//===----------------------------------------------------------------------===// 9113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 10113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// This pass statically checks for common and easily-identified constructs 11113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// which produce undefined or likely unintended behavior in LLVM IR. 12113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 13113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// It is not a guarantee of correctness, in two ways. First, it isn't 14113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// comprehensive. There are checks which could be done statically which are 15113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// not yet implemented. Some of these are indicated by TODO comments, but 16113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// those aren't comprehensive either. Second, many conditions cannot be 17113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// checked statically. This pass does no dynamic instrumentation, so it 18113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// can't check for all possible problems. 19113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 20113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// Another limitation is that it assumes all code will be executed. A store 21113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// through a null pointer in a basic block which is never reached is harmless, 22113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// but this pass will warn about it anyway. 230883355976328699815a7e3ef2efba2a9fd81e02Dan Gohman// 24113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// Optimization passes may make conditions that this pass checks for more or 25113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// less obvious. If an optimization pass appears to be introducing a warning, 26113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// it may be that the optimization pass is merely exposing an existing 27113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// condition in the code. 28113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 29113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// This code may be run before instcombine. In many cases, instcombine checks 30113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// for the same kinds of things and turns instructions with undefined behavior 31113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// into unreachable (or equivalent). Because of this, this pass makes some 32113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// effort to look through bitcasts and so on. 33113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 34113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman//===----------------------------------------------------------------------===// 35113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 36113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Analysis/Passes.h" 37113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Analysis/AliasAnalysis.h" 38113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Analysis/Lint.h" 39113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Analysis/ValueTracking.h" 40113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Assembly/Writer.h" 41113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Target/TargetData.h" 42113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Pass.h" 43113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/PassManager.h" 44113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/IntrinsicInst.h" 45113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Function.h" 46113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Support/CallSite.h" 47113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Support/Debug.h" 48113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Support/InstVisitor.h" 49113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#include "llvm/Support/raw_ostream.h" 50be02b20a8f9e9503733df945968e48562714dd32Dan Gohman#include "llvm/ADT/STLExtras.h" 51113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanusing namespace llvm; 52113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 53113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmannamespace { 545b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman namespace MemRef { 555b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman static unsigned Read = 1; 565b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman static unsigned Write = 2; 575b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman static unsigned Callee = 4; 585b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman static unsigned Branchee = 8; 595b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman } 605b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman 61113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman class Lint : public FunctionPass, public InstVisitor<Lint> { 62113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman friend class InstVisitor<Lint>; 63113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 64be02b20a8f9e9503733df945968e48562714dd32Dan Gohman void visitFunction(Function &F); 65be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 66113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitCallSite(CallSite CS); 67113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitMemoryReference(Instruction &I, Value *Ptr, unsigned Align, 685b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman const Type *Ty, unsigned Flags); 69113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 70113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitCallInst(CallInst &I); 71113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitInvokeInst(InvokeInst &I); 72113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitReturnInst(ReturnInst &I); 73113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitLoadInst(LoadInst &I); 74113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitStoreInst(StoreInst &I); 75be02b20a8f9e9503733df945968e48562714dd32Dan Gohman void visitXor(BinaryOperator &I); 76be02b20a8f9e9503733df945968e48562714dd32Dan Gohman void visitSub(BinaryOperator &I); 77dd98c4d1859a318e7586f87031db44b215476020Dan Gohman void visitLShr(BinaryOperator &I); 78dd98c4d1859a318e7586f87031db44b215476020Dan Gohman void visitAShr(BinaryOperator &I); 79dd98c4d1859a318e7586f87031db44b215476020Dan Gohman void visitShl(BinaryOperator &I); 80113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitSDiv(BinaryOperator &I); 81113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitUDiv(BinaryOperator &I); 82113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitSRem(BinaryOperator &I); 83113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitURem(BinaryOperator &I); 84113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitAllocaInst(AllocaInst &I); 85113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitVAArgInst(VAArgInst &I); 86113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void visitIndirectBrInst(IndirectBrInst &I); 87dd98c4d1859a318e7586f87031db44b215476020Dan Gohman void visitExtractElementInst(ExtractElementInst &I); 88dd98c4d1859a318e7586f87031db44b215476020Dan Gohman void visitInsertElementInst(InsertElementInst &I); 89be02b20a8f9e9503733df945968e48562714dd32Dan Gohman void visitUnreachableInst(UnreachableInst &I); 90113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 91113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman public: 92113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Module *Mod; 93113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman AliasAnalysis *AA; 94113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman TargetData *TD; 95113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 96113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman std::string Messages; 97113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman raw_string_ostream MessagesStr; 98113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 99113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman static char ID; // Pass identification, replacement for typeid 100113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Lint() : FunctionPass(&ID), MessagesStr(Messages) {} 101113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 102113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman virtual bool runOnFunction(Function &F); 103113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 104113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman virtual void getAnalysisUsage(AnalysisUsage &AU) const { 105113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman AU.setPreservesAll(); 106113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman AU.addRequired<AliasAnalysis>(); 107113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 108113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman virtual void print(raw_ostream &O, const Module *M) const {} 109113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 110113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void WriteValue(const Value *V) { 111113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (!V) return; 112113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (isa<Instruction>(V)) { 113113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << *V << '\n'; 114113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } else { 115113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteAsOperand(MessagesStr, V, true, Mod); 116113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << '\n'; 117113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 118113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 119113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 120113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void WriteType(const Type *T) { 121113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (!T) return; 122113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << ' '; 123113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteTypeSymbolic(MessagesStr, T, Mod); 124113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 125113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 126113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // CheckFailed - A check failed, so print out the condition and the message 127113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // that failed. This provides a nice place to put a breakpoint if you want 128113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // to see why something is not correct. 129113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void CheckFailed(const Twine &Message, 130113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman const Value *V1 = 0, const Value *V2 = 0, 131113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman const Value *V3 = 0, const Value *V4 = 0) { 132113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << Message.str() << "\n"; 133113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V1); 134113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V2); 135113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V3); 136113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V4); 137113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 138113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 139113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void CheckFailed(const Twine &Message, const Value *V1, 140113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman const Type *T2, const Value *V3 = 0) { 141113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << Message.str() << "\n"; 142113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V1); 143113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteType(T2); 144113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteValue(V3); 145113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 146113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 147113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman void CheckFailed(const Twine &Message, const Type *T1, 148113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman const Type *T2 = 0, const Type *T3 = 0) { 149113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MessagesStr << Message.str() << "\n"; 150113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteType(T1); 151113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteType(T2); 152113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman WriteType(T3); 153113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 154113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman }; 155113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 156113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 157113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanchar Lint::ID = 0; 158113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanstatic RegisterPass<Lint> 159113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan GohmanX("lint", "Statically lint-checks LLVM IR", false, true); 160113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 161113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// Assert - We know that cond should be true, if not print an error message. 162113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#define Assert(C, M) \ 163113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman do { if (!(C)) { CheckFailed(M); return; } } while (0) 164113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#define Assert1(C, M, V1) \ 165113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman do { if (!(C)) { CheckFailed(M, V1); return; } } while (0) 166113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#define Assert2(C, M, V1, V2) \ 167113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0) 168113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#define Assert3(C, M, V1, V2, V3) \ 169113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman do { if (!(C)) { CheckFailed(M, V1, V2, V3); return; } } while (0) 170113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman#define Assert4(C, M, V1, V2, V3, V4) \ 171113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0) 172113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 173113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// Lint::run - This is the main Analysis entry point for a 174113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// function. 175113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// 176113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanbool Lint::runOnFunction(Function &F) { 177113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Mod = F.getParent(); 178113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman AA = &getAnalysis<AliasAnalysis>(); 179113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman TD = getAnalysisIfAvailable<TargetData>(); 180113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman visit(F); 181113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman dbgs() << MessagesStr.str(); 182a0f7ff334f86926356491ec78ab3066247dc93b1Dan Gohman Messages.clear(); 183113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman return false; 184113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 185113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 186be02b20a8f9e9503733df945968e48562714dd32Dan Gohmanvoid Lint::visitFunction(Function &F) { 187be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // This isn't undefined behavior, it's just a little unusual, and it's a 188be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // fairly common mistake to neglect to name a function. 189be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(F.hasName() || F.hasLocalLinkage(), 190be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Unusual: Unnamed function with non-local linkage", &F); 191113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 192113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 193113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitCallSite(CallSite CS) { 194113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Instruction &I = *CS.getInstruction(); 195113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Value *Callee = CS.getCalledValue(); 196113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 1975b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, Callee, 0, 0, MemRef::Callee); 198113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 199113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (Function *F = dyn_cast<Function>(Callee->stripPointerCasts())) { 200113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(CS.getCallingConv() == F->getCallingConv(), 201be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Caller and callee calling convention differ", 202be02b20a8f9e9503733df945968e48562714dd32Dan Gohman &I); 203113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 204113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman const FunctionType *FT = F->getFunctionType(); 205113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin()); 206113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 207113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(FT->isVarArg() ? 208113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman FT->getNumParams() <= NumActualArgs : 209113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman FT->getNumParams() == NumActualArgs, 210be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Call argument count mismatches callee " 211be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "argument count", &I); 212113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 213113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // TODO: Check argument types (in case the callee was casted) 214113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 215113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // TODO: Check ABI-significant attributes. 216113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 217113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // TODO: Check noalias attribute. 218113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 219113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // TODO: Check sret attribute. 220113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 221113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 222113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman if (CS.isCall() && cast<CallInst>(CS.getInstruction())->isTailCall()) 223113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman for (CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end(); 224113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman AI != AE; ++AI) { 225113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman Value *Obj = (*AI)->getUnderlyingObject(); 226113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman Assert1(!isa<AllocaInst>(Obj) && !isa<VAArgInst>(Obj), 227113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman "Undefined behavior: Call with \"tail\" keyword references " 228113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman "alloca or va_arg", &I); 229113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman } 230113b3e2c6e30efd7c852d31e98b2d21778e52d1eDan Gohman 231113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 232113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I)) 233113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman switch (II->getIntrinsicID()) { 234113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman default: break; 235113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 236113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // TODO: Check more intrinsics 237113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 238113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::memcpy: { 239113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MemCpyInst *MCI = cast<MemCpyInst>(&I); 2405b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, MCI->getSource(), MCI->getAlignment(), 0, 2415b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Write); 2425b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, MCI->getDest(), MCI->getAlignment(), 0, 2435b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read); 244113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 245be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // Check that the memcpy arguments don't overlap. The AliasAnalysis API 246be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // isn't expressive enough for what we really want to do. Known partial 247be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // overlap is not distinguished from the case where nothing is known. 248113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman unsigned Size = 0; 249113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (const ConstantInt *Len = 250113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman dyn_cast<ConstantInt>(MCI->getLength()->stripPointerCasts())) 251113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (Len->getValue().isIntN(32)) 252113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Size = Len->getValue().getZExtValue(); 253113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) != 254113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman AliasAnalysis::MustAlias, 255be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: memcpy source and destination overlap", &I); 256113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 257113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 258113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::memmove: { 259113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MemMoveInst *MMI = cast<MemMoveInst>(&I); 2605b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, MMI->getSource(), MMI->getAlignment(), 0, 2615b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Write); 2625b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, MMI->getDest(), MMI->getAlignment(), 0, 2635b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read); 264113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 265113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 266113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::memset: { 267113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman MemSetInst *MSI = cast<MemSetInst>(&I); 2685b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, MSI->getDest(), MSI->getAlignment(), 0, 2695b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Write); 270113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 271113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 272113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 273113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::vastart: 274be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(I.getParent()->getParent()->isVarArg(), 275be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: va_start called in a non-varargs function", 276be02b20a8f9e9503733df945968e48562714dd32Dan Gohman &I); 277be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 2785b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, CS.getArgument(0), 0, 0, 2795b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read | MemRef::Write); 280113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 281113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::vacopy: 2825b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, CS.getArgument(0), 0, 0, MemRef::Write); 2835b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, CS.getArgument(1), 0, 0, MemRef::Read); 284113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 285113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman case Intrinsic::vaend: 2865b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, CS.getArgument(0), 0, 0, 2875b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read | MemRef::Write); 288113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman break; 289882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman 290882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman case Intrinsic::stackrestore: 291882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman // Stackrestore doesn't read or write memory, but it sets the 292882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman // stack pointer, which the compiler may read from or write to 293882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman // at any time, so check it for both readability and writeability. 294882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman visitMemoryReference(I, CS.getArgument(0), 0, 0, 295882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman MemRef::Read | MemRef::Write); 296882ddb492d9d5497514ac5c084686f07716115e8Dan Gohman break; 297113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 298113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 299113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 300113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitCallInst(CallInst &I) { 301113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman return visitCallSite(&I); 302113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 303113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 304113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitInvokeInst(InvokeInst &I) { 305113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman return visitCallSite(&I); 306113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 307113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 308113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitReturnInst(ReturnInst &I) { 309113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Function *F = I.getParent()->getParent(); 310113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(!F->doesNotReturn(), 311be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Unusual: Return statement in function with noreturn attribute", 312be02b20a8f9e9503733df945968e48562714dd32Dan Gohman &I); 313292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman 314292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman if (Value *V = I.getReturnValue()) { 315292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman Value *Obj = V->getUnderlyingObject(); 316292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman Assert1(!isa<AllocaInst>(Obj) && !isa<VAArgInst>(Obj), 317292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman "Unusual: Returning alloca or va_arg value", &I); 318292fc87fe2f1611e7c83a61796ab71db6a0f7d97Dan Gohman } 319113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 320113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 321113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// TODO: Add a length argument and check that the reference is in bounds 322113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitMemoryReference(Instruction &I, 3235b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Value *Ptr, unsigned Align, const Type *Ty, 3245b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman unsigned Flags) { 325be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Value *UnderlyingObject = Ptr->getUnderlyingObject(); 326be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isa<ConstantPointerNull>(UnderlyingObject), 327be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Null pointer dereference", &I); 328be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isa<UndefValue>(UnderlyingObject), 329be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Undef pointer dereference", &I); 330113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 3315b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman if (Flags & MemRef::Write) { 3325b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(UnderlyingObject)) 3335b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!GV->isConstant(), 3345b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Undefined behavior: Write to read-only memory", &I); 3355b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!isa<Function>(UnderlyingObject) && 3365b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman !isa<BlockAddress>(UnderlyingObject), 3375b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Undefined behavior: Write to text section", &I); 3385b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman } 3395b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman if (Flags & MemRef::Read) { 3405b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!isa<Function>(UnderlyingObject), 3415b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Unusual: Load from function body", &I); 3425b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!isa<BlockAddress>(UnderlyingObject), 3435b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Undefined behavior: Load from block address", &I); 3445b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman } 3455b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman if (Flags & MemRef::Callee) { 3465b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!isa<BlockAddress>(UnderlyingObject), 3475b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Undefined behavior: Call to block address", &I); 3485b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman } 3495b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman if (Flags & MemRef::Branchee) { 3505b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman Assert1(!isa<Constant>(UnderlyingObject) || 3515b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman isa<BlockAddress>(UnderlyingObject), 3525b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman "Undefined behavior: Branch to non-blockaddress", &I); 3535b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman } 3545b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman 355113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (TD) { 356113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (Align == 0 && Ty) Align = TD->getABITypeAlignment(Ty); 357113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 358113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (Align != 0) { 359113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman unsigned BitWidth = TD->getTypeSizeInBits(Ptr->getType()); 360113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman APInt Mask = APInt::getAllOnesValue(BitWidth), 361113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); 362113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman ComputeMaskedBits(Ptr, Mask, KnownZero, KnownOne, TD); 363113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(!(KnownOne & APInt::getLowBitsSet(BitWidth, Log2_32(Align))), 364be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Memory reference address is misaligned", &I); 365113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 366113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman } 367113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 368113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 369113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitLoadInst(LoadInst &I) { 3705b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, I.getPointerOperand(), I.getAlignment(), I.getType(), 3715b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read); 372113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 373113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 374113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitStoreInst(StoreInst &I) { 375113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman visitMemoryReference(I, I.getPointerOperand(), I.getAlignment(), 3765b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman I.getOperand(0)->getType(), MemRef::Write); 377113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 378113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 379be02b20a8f9e9503733df945968e48562714dd32Dan Gohmanvoid Lint::visitXor(BinaryOperator &I) { 380be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isa<UndefValue>(I.getOperand(0)) || 381be02b20a8f9e9503733df945968e48562714dd32Dan Gohman !isa<UndefValue>(I.getOperand(1)), 382be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: xor(undef, undef)", &I); 383be02b20a8f9e9503733df945968e48562714dd32Dan Gohman} 384be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 385be02b20a8f9e9503733df945968e48562714dd32Dan Gohmanvoid Lint::visitSub(BinaryOperator &I) { 386be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isa<UndefValue>(I.getOperand(0)) || 387be02b20a8f9e9503733df945968e48562714dd32Dan Gohman !isa<UndefValue>(I.getOperand(1)), 388be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: sub(undef, undef)", &I); 389be02b20a8f9e9503733df945968e48562714dd32Dan Gohman} 390be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 391dd98c4d1859a318e7586f87031db44b215476020Dan Gohmanvoid Lint::visitLShr(BinaryOperator &I) { 392dd98c4d1859a318e7586f87031db44b215476020Dan Gohman if (ConstantInt *CI = 393dd98c4d1859a318e7586f87031db44b215476020Dan Gohman dyn_cast<ConstantInt>(I.getOperand(1)->stripPointerCasts())) 394dd98c4d1859a318e7586f87031db44b215476020Dan Gohman Assert1(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), 395be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: Shift count out of range", &I); 396dd98c4d1859a318e7586f87031db44b215476020Dan Gohman} 397dd98c4d1859a318e7586f87031db44b215476020Dan Gohman 398dd98c4d1859a318e7586f87031db44b215476020Dan Gohmanvoid Lint::visitAShr(BinaryOperator &I) { 399dd98c4d1859a318e7586f87031db44b215476020Dan Gohman if (ConstantInt *CI = 400dd98c4d1859a318e7586f87031db44b215476020Dan Gohman dyn_cast<ConstantInt>(I.getOperand(1)->stripPointerCasts())) 401dd98c4d1859a318e7586f87031db44b215476020Dan Gohman Assert1(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), 402be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: Shift count out of range", &I); 403dd98c4d1859a318e7586f87031db44b215476020Dan Gohman} 404dd98c4d1859a318e7586f87031db44b215476020Dan Gohman 405dd98c4d1859a318e7586f87031db44b215476020Dan Gohmanvoid Lint::visitShl(BinaryOperator &I) { 406dd98c4d1859a318e7586f87031db44b215476020Dan Gohman if (ConstantInt *CI = 407dd98c4d1859a318e7586f87031db44b215476020Dan Gohman dyn_cast<ConstantInt>(I.getOperand(1)->stripPointerCasts())) 408dd98c4d1859a318e7586f87031db44b215476020Dan Gohman Assert1(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), 409be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: Shift count out of range", &I); 410dd98c4d1859a318e7586f87031db44b215476020Dan Gohman} 411dd98c4d1859a318e7586f87031db44b215476020Dan Gohman 412113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanstatic bool isZero(Value *V, TargetData *TD) { 413be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // Assume undef could be zero. 414be02b20a8f9e9503733df945968e48562714dd32Dan Gohman if (isa<UndefValue>(V)) return true; 415be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 416113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman unsigned BitWidth = cast<IntegerType>(V->getType())->getBitWidth(); 417113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman APInt Mask = APInt::getAllOnesValue(BitWidth), 418113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); 419113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman ComputeMaskedBits(V, Mask, KnownZero, KnownOne, TD); 420113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman return KnownZero.isAllOnesValue(); 421113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 422113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 423113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitSDiv(BinaryOperator &I) { 424be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isZero(I.getOperand(1), TD), 425be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Division by zero", &I); 426113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 427113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 428113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitUDiv(BinaryOperator &I) { 429be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isZero(I.getOperand(1), TD), 430be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Division by zero", &I); 431113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 432113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 433113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitSRem(BinaryOperator &I) { 434be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isZero(I.getOperand(1), TD), 435be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Division by zero", &I); 436113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 437113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 438113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitURem(BinaryOperator &I) { 439be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(!isZero(I.getOperand(1), TD), 440be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined behavior: Division by zero", &I); 441113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 442113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 443113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitAllocaInst(AllocaInst &I) { 444113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman if (isa<ConstantInt>(I.getArraySize())) 445113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman // This isn't undefined behavior, it's just an obvious pessimization. 446113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Assert1(&I.getParent()->getParent()->getEntryBlock() == I.getParent(), 447be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Pessimization: Static alloca outside of entry block", &I); 448113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 449113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 450113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitVAArgInst(VAArgInst &I) { 4515b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, I.getOperand(0), 0, 0, 4525b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman MemRef::Read | MemRef::Write); 453113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 454113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 455113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid Lint::visitIndirectBrInst(IndirectBrInst &I) { 4565b61b3818a3aadb928485571d69e5bccc52e1d5bDan Gohman visitMemoryReference(I, I.getAddress(), 0, 0, MemRef::Branchee); 457113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 458113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 459dd98c4d1859a318e7586f87031db44b215476020Dan Gohmanvoid Lint::visitExtractElementInst(ExtractElementInst &I) { 460dd98c4d1859a318e7586f87031db44b215476020Dan Gohman if (ConstantInt *CI = 461dd98c4d1859a318e7586f87031db44b215476020Dan Gohman dyn_cast<ConstantInt>(I.getIndexOperand()->stripPointerCasts())) 462dd98c4d1859a318e7586f87031db44b215476020Dan Gohman Assert1(CI->getValue().ult(I.getVectorOperandType()->getNumElements()), 463be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: extractelement index out of range", &I); 464dd98c4d1859a318e7586f87031db44b215476020Dan Gohman} 465dd98c4d1859a318e7586f87031db44b215476020Dan Gohman 466dd98c4d1859a318e7586f87031db44b215476020Dan Gohmanvoid Lint::visitInsertElementInst(InsertElementInst &I) { 467dd98c4d1859a318e7586f87031db44b215476020Dan Gohman if (ConstantInt *CI = 468dd98c4d1859a318e7586f87031db44b215476020Dan Gohman dyn_cast<ConstantInt>(I.getOperand(2)->stripPointerCasts())) 469dd98c4d1859a318e7586f87031db44b215476020Dan Gohman Assert1(CI->getValue().ult(I.getType()->getNumElements()), 470be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Undefined result: insertelement index out of range", &I); 471be02b20a8f9e9503733df945968e48562714dd32Dan Gohman} 472be02b20a8f9e9503733df945968e48562714dd32Dan Gohman 473be02b20a8f9e9503733df945968e48562714dd32Dan Gohmanvoid Lint::visitUnreachableInst(UnreachableInst &I) { 474be02b20a8f9e9503733df945968e48562714dd32Dan Gohman // This isn't undefined behavior, it's merely suspicious. 475be02b20a8f9e9503733df945968e48562714dd32Dan Gohman Assert1(&I == I.getParent()->begin() || 476be02b20a8f9e9503733df945968e48562714dd32Dan Gohman prior(BasicBlock::iterator(&I))->mayHaveSideEffects(), 477be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "Unusual: unreachable immediately preceded by instruction without " 478be02b20a8f9e9503733df945968e48562714dd32Dan Gohman "side effects", &I); 479dd98c4d1859a318e7586f87031db44b215476020Dan Gohman} 480dd98c4d1859a318e7586f87031db44b215476020Dan Gohman 481113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman//===----------------------------------------------------------------------===// 482113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman// Implement the public interfaces to this file... 483113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman//===----------------------------------------------------------------------===// 484113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 485113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan GohmanFunctionPass *llvm::createLintPass() { 486113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman return new Lint(); 487113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 488113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 489113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman/// lintFunction - Check a function for errors, printing messages on stderr. 490113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman/// 491113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohmanvoid llvm::lintFunction(const Function &f) { 492113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Function &F = const_cast<Function&>(f); 493113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman assert(!F.isDeclaration() && "Cannot lint external functions"); 494113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 495113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman FunctionPassManager FPM(F.getParent()); 496113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Lint *V = new Lint(); 497113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman FPM.add(V); 498113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman FPM.run(F); 499113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 500113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman 501113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman/// lintModule - Check a module for errors, printing messages on stderr. 502113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman/// 503a0f7ff334f86926356491ec78ab3066247dc93b1Dan Gohmanvoid llvm::lintModule(const Module &M) { 504113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman PassManager PM; 505113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman Lint *V = new Lint(); 506113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman PM.add(V); 507113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman PM.run(const_cast<Module&>(M)); 508113902e9fba5f4baf3de3c6ac0241d49ffdfa55cDan Gohman} 509