LLVM API Documentation

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

AliasAnalysisCounter.cpp

Go to the documentation of this file.
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/AliasAnalysis.h"
00016 #include "llvm/Pass.h"
00017 #include <iostream>
00018 using namespace llvm;
00019 
00020 namespace {
00021   class AliasAnalysisCounter : public ModulePass, public AliasAnalysis {
00022     unsigned No, May, Must;
00023     unsigned NoMR, JustRef, JustMod, MR;
00024     const char *Name;
00025   public:
00026     AliasAnalysisCounter() {
00027       No = May = Must = 0;
00028       NoMR = JustRef = JustMod = MR = 0;
00029     }
00030 
00031     void printLine(const char *Desc, unsigned Val, unsigned Sum) {
00032       std::cerr <<  "  " << Val << " " << Desc << " responses ("
00033                 << Val*100/Sum << "%)\n";
00034     }
00035     ~AliasAnalysisCounter() {
00036       unsigned AASum = No+May+Must;
00037       unsigned MRSum = NoMR+JustRef+JustMod+MR;
00038       if (AASum + MRSum) { // Print a report if any counted queries occurred...
00039         std::cerr
00040           << "\n===== Alias Analysis Counter Report =====\n"
00041           << "  Analysis counted: " << Name << "\n"
00042           << "  " << AASum << " Total Alias Queries Performed\n";
00043         if (AASum) {
00044           printLine("no alias",     No, AASum);
00045           printLine("may alias",   May, AASum);
00046           printLine("must alias", Must, AASum);
00047           std::cerr
00048             << "  Alias Analysis Counter Summary: " << No*100/AASum << "%/"
00049             << May*100/AASum << "%/" << Must*100/AASum<<"%\n\n";
00050         }
00051 
00052         std::cerr
00053           << "  " << MRSum    << " Total Mod/Ref Queries Performed\n";
00054         if (MRSum) {
00055           printLine("no mod/ref",    NoMR, MRSum);
00056           printLine("ref",        JustRef, MRSum);
00057           printLine("mod",        JustMod, MRSum);
00058           printLine("mod/ref",         MR, MRSum);
00059           std::cerr
00060             << "  Mod/Ref Analysis Counter Summary: " << NoMR*100/MRSum<< "%/"
00061             << JustRef*100/MRSum << "%/" << JustMod*100/MRSum << "%/" 
00062             << MR*100/MRSum <<"%\n\n";
00063         }
00064       }
00065     }
00066 
00067     bool runOnModule(Module &M) {
00068       InitializeAliasAnalysis(this);
00069       Name = dynamic_cast<Pass*>(&getAnalysis<AliasAnalysis>())->getPassName();
00070       return false;
00071     }
00072 
00073     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
00074       AliasAnalysis::getAnalysisUsage(AU);
00075       AU.addRequired<AliasAnalysis>();
00076       AU.setPreservesAll();
00077     }
00078 
00079     AliasResult count(AliasResult R) {
00080       switch (R) {
00081       default: assert(0 && "Unknown alias type!");
00082       case NoAlias:   No++; return NoAlias;
00083       case MayAlias:  May++; return MayAlias;
00084       case MustAlias: Must++; return MustAlias;
00085       }
00086     }
00087     ModRefResult count(ModRefResult R) {
00088       switch (R) {
00089       default:       assert(0 && "Unknown mod/ref type!");
00090       case NoModRef: NoMR++;     return NoModRef;
00091       case Ref:      JustRef++;  return Ref;
00092       case Mod:      JustMod++;  return Mod;
00093       case ModRef:   MR++;       return ModRef;
00094       }
00095     }
00096 
00097     // FIXME: We could count these too...
00098     bool pointsToConstantMemory(const Value *P) {
00099       return getAnalysis<AliasAnalysis>().pointsToConstantMemory(P);
00100     }
00101     bool doesNotAccessMemory(Function *F) {
00102       return getAnalysis<AliasAnalysis>().doesNotAccessMemory(F);
00103     }
00104     bool onlyReadsMemory(Function *F) {
00105       return getAnalysis<AliasAnalysis>().onlyReadsMemory(F);
00106     }
00107     
00108     
00109     // Forwarding functions: just delegate to a real AA implementation, counting
00110     // the number of responses...
00111     AliasResult alias(const Value *V1, unsigned V1Size,
00112                       const Value *V2, unsigned V2Size) {
00113       return count(getAnalysis<AliasAnalysis>().alias(V1, V1Size, V2, V2Size));
00114     }
00115     ModRefResult getModRefInfo(CallSite CS, Value *P, unsigned Size) {
00116       return count(getAnalysis<AliasAnalysis>().getModRefInfo(CS, P, Size));
00117     }
00118   };
00119 
00120   RegisterOpt<AliasAnalysisCounter>
00121   X("count-aa", "Count Alias Analysis Query Responses");
00122   RegisterAnalysisGroup<AliasAnalysis, AliasAnalysisCounter> Y;
00123 }