AliasDebugger.cpp revision 5cbf985dcbc89fba3208e7baf8b6f488b06d3ec9
1//===- AliasDebugger.cpp - Simple Alias Analysis Use Checker --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by Andrew Lenharth and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This simple pass checks alias analysis users to ensure that if they 11// create a new value, they do not query AA without informing it of the value. 12// It acts as a shim over any other AA pass you want. 13// 14// Yes keeping track of every value in the program is expensive, but this is 15// a debugging pass. 16// 17//===----------------------------------------------------------------------===// 18 19#include "llvm/Analysis/Passes.h" 20#include "llvm/Module.h" 21#include "llvm/Pass.h" 22#include "llvm/Instructions.h" 23#include "llvm/Constants.h" 24#include "llvm/DerivedTypes.h" 25#include "llvm/Analysis/AliasAnalysis.h" 26#include <set> 27using namespace llvm; 28 29namespace { 30 31 class AliasDebugger : public ModulePass, public AliasAnalysis { 32 33 //What we do is simple. Keep track of every value the AA could 34 //know about, and verify that queries are one of those. 35 //A query to a value that didn't exist when the AA was created 36 //means someone forgot to update the AA when creating new values 37 38 std::set<const Value*> Vals; 39 40 public: 41 bool runOnModule(Module &M) { 42 InitializeAliasAnalysis(this); // set up super class 43 44 for(Module::global_iterator I = M.global_begin(), 45 E = M.global_end(); I != E; ++I) 46 Vals.insert(&*I); 47 48 for(Module::iterator I = M.begin(), 49 E = M.end(); I != E; ++I){ 50 Vals.insert(&*I); 51 if(!I->isDeclaration()) { 52 for (Function::arg_iterator AI = I->arg_begin(), AE = I->arg_end(); 53 AI != AE; ++AI) 54 Vals.insert(&*AI); 55 for (Function::const_iterator FI = I->begin(), FE = I->end(); 56 FI != FE; ++FI) 57 for (BasicBlock::const_iterator BI = FI->begin(), BE = FI->end(); 58 BI != BE; ++BI) 59 Vals.insert(&*BI); 60 } 61 62 } 63 return false; 64 } 65 66 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 67 AliasAnalysis::getAnalysisUsage(AU); 68 AU.setPreservesAll(); // Does not transform code 69 } 70 71 //------------------------------------------------ 72 // Implement the AliasAnalysis API 73 // 74 AliasResult alias(const Value *V1, unsigned V1Size, 75 const Value *V2, unsigned V2Size) { 76 assert(Vals.find(V1) != Vals.end() && "Never seen value in AA before"); 77 assert(Vals.find(V2) != Vals.end() && "Never seen value in AA before"); 78 return AliasAnalysis::alias(V1, V1Size, V2, V2Size); 79 } 80 81 ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size) { 82 assert(Vals.find(P) != Vals.end() && "Never seen value in AA before"); 83 return AliasAnalysis::getModRefInfo(CS, P, Size); 84 } 85 86 ModRefResult getModRefInfo(CallSite CS1, CallSite CS2) { 87 return AliasAnalysis::getModRefInfo(CS1,CS2); 88 } 89 90 void getMustAliases(Value *P, std::vector<Value*> &RetVals) { 91 assert(Vals.find(P) != Vals.end() && "Never seen value in AA before"); 92 return AliasAnalysis::getMustAliases(P, RetVals); 93 } 94 95 bool pointsToConstantMemory(const Value *P) { 96 assert(Vals.find(P) != Vals.end() && "Never seen value in AA before"); 97 return AliasAnalysis::pointsToConstantMemory(P); 98 } 99 100 /// getModRefBehavior - Return the behavior of the specified function if 101 /// called from the specified call site. The call site may be null in which 102 /// case the most generic behavior of this function should be returned. 103 virtual ModRefBehavior getModRefBehavior(Function *F, CallSite CS, 104 std::vector<PointerAccessInfo> *Info) { 105 assert(Vals.find(F) != Vals.end() && "Never seen value in AA before"); 106 return AliasAnalysis::getModRefBehavior(F, CS, Info); 107 } 108 109 virtual void deleteValue(Value *V) { 110 assert(Vals.find(V) != Vals.end() && "Never seen value in AA before"); 111 AliasAnalysis::deleteValue(V); 112 } 113 virtual void copyValue(Value *From, Value *To) { 114 Vals.insert(To); 115 AliasAnalysis::copyValue(From, To); 116 } 117 118 }; 119 120 RegisterPass<AliasDebugger> X("debug-aa", "AA use debugger"); 121 RegisterAnalysisGroup<AliasAnalysis> Y(X); 122} 123 124Pass *llvm::createAliasDebugger() { return new AliasDebugger(); } 125 126