lib/Analysis/AliasAnalysisCounter.cpp

   1 //===- AliasAnalysisCounter.cpp - Alias Analysis Query Counter ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements a pass which can be used to count how many alias queries
  11 // are being made and how the alias analysis implementation being used responds.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Analysis/AliasAnalysisCounter.h"
  16 #include "llvm/Analysis/AliasAnalysis.h"
  17 #include "llvm/IR/Module.h"
  18 #include "llvm/Pass.h"
  19 #include "llvm/Support/CommandLine.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/ErrorHandling.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 using namespace llvm;
  24
  25 static cl::opt<bool> PrintAll("count-aa-print-all-queries", cl::ReallyHidden,
  26                               cl::init(true));
  27 static cl::opt<bool> PrintAllFailures("count-aa-print-all-failed-queries",
  28                                       cl::ReallyHidden);
  29
  30 char AliasAnalysisCounter::ID = 0;
  31 INITIALIZE_AG_PASS(AliasAnalysisCounter, AliasAnalysis, "count-aa",
  32                    "Count Alias Analysis Query Responses", false, true, false)
  33
  34 ModulePass *llvm::createAliasAnalysisCounterPass() {
  35   return new AliasAnalysisCounter();
  36 }
  37
  38 AliasAnalysisCounter::AliasAnalysisCounter() : ModulePass(ID) {
  39   initializeAliasAnalysisCounterPass(*PassRegistry::getPassRegistry());
  40   No = May = Partial = Must = 0;
  41   NoMR = JustRef = JustMod = MR = 0;
  42 }
  43
  44 static void printLine(const char *Desc, unsigned Val, unsigned Sum) {
  45   errs() << "  " << Val << " " << Desc << " responses (" << Val * 100 / Sum
  46          << "%)\n";
  47 }
  48
  49 AliasAnalysisCounter::~AliasAnalysisCounter() {
  50   unsigned AASum = No + May + Partial + Must;
  51   unsigned MRSum = NoMR + JustRef + JustMod + MR;
  52   if (AASum + MRSum) { // Print a report if any counted queries occurred...
  53     errs() << "\n===== Alias Analysis Counter Report =====\n"
  54            << "  Analysis counted:\n"
  55            << "  " << AASum << " Total Alias Queries Performed\n";
  56     if (AASum) {
  57       printLine("no alias", No, AASum);
  58       printLine("may alias", May, AASum);
  59       printLine("partial alias", Partial, AASum);
  60       printLine("must alias", Must, AASum);
  61       errs() << "  Alias Analysis Counter Summary: " << No * 100 / AASum << "%/"
  62              << May * 100 / AASum << "%/" << Partial * 100 / AASum << "%/"
  63              << Must * 100 / AASum << "%\n\n";
  64     }
  65
  66     errs() << "  " << MRSum << " Total MRI_Mod/MRI_Ref Queries Performed\n";
  67     if (MRSum) {
  68       printLine("no mod/ref", NoMR, MRSum);
  69       printLine("ref", JustRef, MRSum);
  70       printLine("mod", JustMod, MRSum);
  71       printLine("mod/ref", MR, MRSum);
  72       errs() << "  MRI_Mod/MRI_Ref Analysis Counter Summary: "
  73              << NoMR * 100 / MRSum << "%/" << JustRef * 100 / MRSum << "%/"
  74              << JustMod * 100 / MRSum << "%/" << MR * 100 / MRSum << "%\n\n";
  75     }
  76   }
  77 }
  78
  79 bool AliasAnalysisCounter::runOnModule(Module &M) {
  80   this->M = &M;
  81   InitializeAliasAnalysis(this, &M.getDataLayout());
  82   return false;
  83 }
  84
  85 void AliasAnalysisCounter::getAnalysisUsage(AnalysisUsage &AU) const {
  86   AliasAnalysis::getAnalysisUsage(AU);
  87   AU.addRequired<AliasAnalysis>();
  88   AU.setPreservesAll();
  89 }
  90
  91 void *AliasAnalysisCounter::getAdjustedAnalysisPointer(AnalysisID PI) {
  92   if (PI == &AliasAnalysis::ID)
  93     return (AliasAnalysis *)this;
  94   return this;
  95 }
  96
  97 AliasResult AliasAnalysisCounter::alias(const MemoryLocation &LocA,
  98                                         const MemoryLocation &LocB) {
  99   AliasResult R = getAnalysis<AliasAnalysis>().alias(LocA, LocB);
 100
 101   const char *AliasString = nullptr;
 102   switch (R) {
 103   case NoAlias:
 104     No++;
 105     AliasString = "No alias";
 106     break;
 107   case MayAlias:
 108     May++;
 109     AliasString = "May alias";
 110     break;
 111   case PartialAlias:
 112     Partial++;
 113     AliasString = "Partial alias";
 114     break;
 115   case MustAlias:
 116     Must++;
 117     AliasString = "Must alias";
 118     break;
 119   }
 120
 121   if (PrintAll || (PrintAllFailures && R == MayAlias)) {
 122     errs() << AliasString << ":\t";
 123     errs() << "[" << LocA.Size << "B] ";
 124     LocA.Ptr->printAsOperand(errs(), true, M);
 125     errs() << ", ";
 126     errs() << "[" << LocB.Size << "B] ";
 127     LocB.Ptr->printAsOperand(errs(), true, M);
 128     errs() << "\n";
 129   }
 130
 131   return R;
 132 }
 133
 134 ModRefInfo AliasAnalysisCounter::getModRefInfo(ImmutableCallSite CS,
 135                                                const MemoryLocation &Loc) {
 136   ModRefInfo R = getAnalysis<AliasAnalysis>().getModRefInfo(CS, Loc);
 137
 138   const char *MRString = nullptr;
 139   switch (R) {
 140   case MRI_NoModRef:
 141     NoMR++;
 142     MRString = "MRI_NoModRef";
 143     break;
 144   case MRI_Ref:
 145     JustRef++;
 146     MRString = "JustRef";
 147     break;
 148   case MRI_Mod:
 149     JustMod++;
 150     MRString = "JustMod";
 151     break;
 152   case MRI_ModRef:
 153     MR++;
 154     MRString = "MRI_ModRef";
 155     break;
 156   }
 157
 158   if (PrintAll || (PrintAllFailures && R == MRI_ModRef)) {
 159     errs() << MRString << ":  Ptr: ";
 160     errs() << "[" << Loc.Size << "B] ";
 161     Loc.Ptr->printAsOperand(errs(), true, M);
 162     errs() << "\t<->" << *CS.getInstruction() << '\n';
 163   }
 164   return R;
 165 }