LLVM API Documentation
00001 //===- AliasAnalysisCounter.cpp - Alias Analysis Query Counter ------------===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file was developed by the LLVM research group and is distributed under 00006 // the University of Illinois Open Source 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 <iostream> 00021 using namespace llvm; 00022 00023 namespace { 00024 cl::opt<bool> 00025 PrintAll("count-aa-print-all-queries", cl::ReallyHidden); 00026 cl::opt<bool> 00027 PrintAllFailures("count-aa-print-all-failed-queries", cl::ReallyHidden); 00028 00029 class AliasAnalysisCounter : public ModulePass, public AliasAnalysis { 00030 unsigned No, May, Must; 00031 unsigned NoMR, JustRef, JustMod, MR; 00032 const char *Name; 00033 Module *M; 00034 public: 00035 AliasAnalysisCounter() { 00036 No = May = Must = 0; 00037 NoMR = JustRef = JustMod = MR = 0; 00038 } 00039 00040 void printLine(const char *Desc, unsigned Val, unsigned Sum) { 00041 std::cerr << " " << Val << " " << Desc << " responses (" 00042 << Val*100/Sum << "%)\n"; 00043 } 00044 ~AliasAnalysisCounter() { 00045 unsigned AASum = No+May+Must; 00046 unsigned MRSum = NoMR+JustRef+JustMod+MR; 00047 if (AASum + MRSum) { // Print a report if any counted queries occurred... 00048 std::cerr 00049 << "\n===== Alias Analysis Counter Report =====\n" 00050 << " Analysis counted: " << Name << "\n" 00051 << " " << AASum << " Total Alias Queries Performed\n"; 00052 if (AASum) { 00053 printLine("no alias", No, AASum); 00054 printLine("may alias", May, AASum); 00055 printLine("must alias", Must, AASum); 00056 std::cerr 00057 << " Alias Analysis Counter Summary: " << No*100/AASum << "%/" 00058 << May*100/AASum << "%/" << Must*100/AASum<<"%\n\n"; 00059 } 00060 00061 std::cerr 00062 << " " << MRSum << " Total Mod/Ref Queries Performed\n"; 00063 if (MRSum) { 00064 printLine("no mod/ref", NoMR, MRSum); 00065 printLine("ref", JustRef, MRSum); 00066 printLine("mod", JustMod, MRSum); 00067 printLine("mod/ref", MR, MRSum); 00068 std::cerr 00069 << " 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(Function *F) { 00094 return getAnalysis<AliasAnalysis>().doesNotAccessMemory(F); 00095 } 00096 bool onlyReadsMemory(Function *F) { 00097 return getAnalysis<AliasAnalysis>().onlyReadsMemory(F); 00098 } 00099 00100 00101 // Forwarding functions: just delegate to a real AA implementation, counting 00102 // the number of responses... 00103 AliasResult alias(const Value *V1, unsigned V1Size, 00104 const Value *V2, unsigned V2Size); 00105 00106 ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size); 00107 ModRefResult getModRefInfo(CallSite CS1, CallSite CS2) { 00108 return AliasAnalysis::getModRefInfo(CS1,CS2); 00109 } 00110 }; 00111 00112 RegisterOpt<AliasAnalysisCounter> 00113 X("count-aa", "Count Alias Analysis Query Responses"); 00114 RegisterAnalysisGroup<AliasAnalysis, AliasAnalysisCounter> Y; 00115 } 00116 00117 ModulePass *llvm::createAliasAnalysisCounterPass() { 00118 return new AliasAnalysisCounter(); 00119 } 00120 00121 AliasAnalysis::AliasResult 00122 AliasAnalysisCounter::alias(const Value *V1, unsigned V1Size, 00123 const Value *V2, unsigned V2Size) { 00124 AliasResult R = getAnalysis<AliasAnalysis>().alias(V1, V1Size, V2, V2Size); 00125 00126 const char *AliasString; 00127 switch (R) { 00128 default: assert(0 && "Unknown alias type!"); 00129 case NoAlias: No++; AliasString = "No alias"; break; 00130 case MayAlias: May++; AliasString = "May alias"; break; 00131 case MustAlias: Must++; AliasString = "Must alias"; break; 00132 } 00133 00134 if (PrintAll || (PrintAllFailures && R == MayAlias)) { 00135 std::cerr << AliasString << ":\t"; 00136 std::cerr << "[" << V1Size << "B] "; 00137 WriteAsOperand(std::cerr, V1, true, true, M) << ", "; 00138 std::cerr << "[" << V2Size << "B] "; 00139 WriteAsOperand(std::cerr, V2, true, true, M) << "\n"; 00140 } 00141 00142 return R; 00143 } 00144 00145 AliasAnalysis::ModRefResult 00146 AliasAnalysisCounter::getModRefInfo(CallSite CS, Value *P, unsigned Size) { 00147 ModRefResult R = getAnalysis<AliasAnalysis>().getModRefInfo(CS, P, Size); 00148 00149 const char *MRString; 00150 switch (R) { 00151 default: assert(0 && "Unknown mod/ref type!"); 00152 case NoModRef: NoMR++; MRString = "NoModRef"; break; 00153 case Ref: JustRef++; MRString = "JustRef"; break; 00154 case Mod: JustMod++; MRString = "JustMod"; break; 00155 case ModRef: MR++; MRString = "ModRef"; break; 00156 } 00157 00158 if (PrintAll || (PrintAllFailures && R == ModRef)) { 00159 std::cerr << MRString << ": Ptr: "; 00160 std::cerr << "[" << Size << "B] "; 00161 WriteAsOperand(std::cerr, P, true, true, M); 00162 std::cerr << "\t<->" << *CS.getInstruction(); 00163 } 00164 return R; 00165 }