LLVM API Documentation
00001 //===- AliasAnalysisCounter.cpp - Alias Analysis Query Counter ------------===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file implements a pass which can be used to count how many alias queries 00011 // are being made and how the alias analysis implementation being used responds. 00012 // 00013 //===----------------------------------------------------------------------===// 00014 00015 #include "llvm/Analysis/Passes.h" 00016 #include "llvm/Pass.h" 00017 #include "llvm/Analysis/AliasAnalysis.h" 00018 #include "llvm/Assembly/Writer.h" 00019 #include "llvm/Support/CommandLine.h" 00020 #include "llvm/Support/Compiler.h" 00021 #include "llvm/Support/ErrorHandling.h" 00022 #include "llvm/Support/Streams.h" 00023 using namespace llvm; 00024 00025 static cl::opt<bool> 00026 PrintAll("count-aa-print-all-queries", cl::ReallyHidden); 00027 static cl::opt<bool> 00028 PrintAllFailures("count-aa-print-all-failed-queries", cl::ReallyHidden); 00029 00030 namespace { 00031 class VISIBILITY_HIDDEN AliasAnalysisCounter 00032 : public ModulePass, public AliasAnalysis { 00033 unsigned No, May, Must; 00034 unsigned NoMR, JustRef, JustMod, MR; 00035 const char *Name; 00036 Module *M; 00037 public: 00038 static char ID; // Class identification, replacement for typeinfo 00039 AliasAnalysisCounter() : ModulePass(&ID) { 00040 No = May = Must = 0; 00041 NoMR = JustRef = JustMod = MR = 0; 00042 } 00043 00044 void printLine(const char *Desc, unsigned Val, unsigned Sum) { 00045 cerr << " " << Val << " " << Desc << " responses (" 00046 << Val*100/Sum << "%)\n"; 00047 } 00048 ~AliasAnalysisCounter() { 00049 unsigned AASum = No+May+Must; 00050 unsigned MRSum = NoMR+JustRef+JustMod+MR; 00051 if (AASum + MRSum) { // Print a report if any counted queries occurred... 00052 cerr << "\n===== Alias Analysis Counter Report =====\n" 00053 << " Analysis counted: " << Name << "\n" 00054 << " " << AASum << " Total Alias Queries Performed\n"; 00055 if (AASum) { 00056 printLine("no alias", No, AASum); 00057 printLine("may alias", May, AASum); 00058 printLine("must alias", Must, AASum); 00059 cerr << " Alias Analysis Counter Summary: " << No*100/AASum << "%/" 00060 << May*100/AASum << "%/" << Must*100/AASum<<"%\n\n"; 00061 } 00062 00063 cerr << " " << MRSum << " Total Mod/Ref Queries Performed\n"; 00064 if (MRSum) { 00065 printLine("no mod/ref", NoMR, MRSum); 00066 printLine("ref", JustRef, MRSum); 00067 printLine("mod", JustMod, MRSum); 00068 printLine("mod/ref", MR, MRSum); 00069 cerr << " Mod/Ref Analysis Counter Summary: " <<NoMR*100/MRSum<< "%/" 00070 << JustRef*100/MRSum << "%/" << JustMod*100/MRSum << "%/" 00071 << MR*100/MRSum <<"%\n\n"; 00072 } 00073 } 00074 } 00075 00076 bool runOnModule(Module &M) { 00077 this->M = &M; 00078 InitializeAliasAnalysis(this); 00079 Name = dynamic_cast<Pass*>(&getAnalysis<AliasAnalysis>())->getPassName(); 00080 return false; 00081 } 00082 00083 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 00084 AliasAnalysis::getAnalysisUsage(AU); 00085 AU.addRequired<AliasAnalysis>(); 00086 AU.setPreservesAll(); 00087 } 00088 00089 // FIXME: We could count these too... 00090 bool pointsToConstantMemory(const Value *P) { 00091 return getAnalysis<AliasAnalysis>().pointsToConstantMemory(P); 00092 } 00093 bool doesNotAccessMemory(CallSite CS) { 00094 return getAnalysis<AliasAnalysis>().doesNotAccessMemory(CS); 00095 } 00096 bool doesNotAccessMemory(Function *F) { 00097 return getAnalysis<AliasAnalysis>().doesNotAccessMemory(F); 00098 } 00099 bool onlyReadsMemory(CallSite CS) { 00100 return getAnalysis<AliasAnalysis>().onlyReadsMemory(CS); 00101 } 00102 bool onlyReadsMemory(Function *F) { 00103 return getAnalysis<AliasAnalysis>().onlyReadsMemory(F); 00104 } 00105 00106 00107 // Forwarding functions: just delegate to a real AA implementation, counting 00108 // the number of responses... 00109 AliasResult alias(const Value *V1, unsigned V1Size, 00110 const Value *V2, unsigned V2Size); 00111 00112 ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size); 00113 ModRefResult getModRefInfo(CallSite CS1, CallSite CS2) { 00114 return AliasAnalysis::getModRefInfo(CS1,CS2); 00115 } 00116 }; 00117 } 00118 00119 char AliasAnalysisCounter::ID = 0; 00120 static RegisterPass<AliasAnalysisCounter> 00121 X("count-aa", "Count Alias Analysis Query Responses", false, true); 00122 static RegisterAnalysisGroup<AliasAnalysis> Y(X); 00123 00124 ModulePass *llvm::createAliasAnalysisCounterPass() { 00125 return new AliasAnalysisCounter(); 00126 } 00127 00128 AliasAnalysis::AliasResult 00129 AliasAnalysisCounter::alias(const Value *V1, unsigned V1Size, 00130 const Value *V2, unsigned V2Size) { 00131 AliasResult R = getAnalysis<AliasAnalysis>().alias(V1, V1Size, V2, V2Size); 00132 00133 const char *AliasString; 00134 switch (R) { 00135 default: llvm_unreachable("Unknown alias type!"); 00136 case NoAlias: No++; AliasString = "No alias"; break; 00137 case MayAlias: May++; AliasString = "May alias"; break; 00138 case MustAlias: Must++; AliasString = "Must alias"; break; 00139 } 00140 00141 if (PrintAll || (PrintAllFailures && R == MayAlias)) { 00142 cerr << AliasString << ":\t"; 00143 cerr << "[" << V1Size << "B] "; 00144 WriteAsOperand(*cerr.stream(), V1, true, M); 00145 cerr << ", "; 00146 cerr << "[" << V2Size << "B] "; 00147 WriteAsOperand(*cerr.stream(), V2, true, M); 00148 cerr << "\n"; 00149 } 00150 00151 return R; 00152 } 00153 00154 AliasAnalysis::ModRefResult 00155 AliasAnalysisCounter::getModRefInfo(CallSite CS, Value *P, unsigned Size) { 00156 ModRefResult R = getAnalysis<AliasAnalysis>().getModRefInfo(CS, P, Size); 00157 00158 const char *MRString; 00159 switch (R) { 00160 default: llvm_unreachable("Unknown mod/ref type!"); 00161 case NoModRef: NoMR++; MRString = "NoModRef"; break; 00162 case Ref: JustRef++; MRString = "JustRef"; break; 00163 case Mod: JustMod++; MRString = "JustMod"; break; 00164 case ModRef: MR++; MRString = "ModRef"; break; 00165 } 00166 00167 if (PrintAll || (PrintAllFailures && R == ModRef)) { 00168 cerr << MRString << ": Ptr: "; 00169 cerr << "[" << Size << "B] "; 00170 WriteAsOperand(*cerr.stream(), P, true, M); 00171 cerr << "\t<->" << *CS.getInstruction(); 00172 } 00173 return R; 00174 }