[PM/AA] Flesh out statistics to cover all the primary use cases of the old AliasAnalysisCounter pass.

[chandlerc]

Summary

That pass also had some debug printing logic in it which I have not at
this time replicated. I'm considering leaving that for folks to add when
the have use cases where it would help rather than trying what wil be
helpful here.

Depends on D12080.

[chandlerc]

Rebase.

[mcrosier]

lib/Analysis/AliasAnalysis.cpp

109

Given the check just before the switch (i.e., Result != MayAlias) can the MayAlias case ever be hit?

[hfinkel]

It seems unfortunate to need to make the AA result statistics essentially part of the boilerplate necessary to implement a good AA provider. Can we move all statistics generation into the aggregrator? We don't need to use the STATISTIC macro, really, the aggregrator can construct a set of such objects based on the names of the underlying providers in its care, and then use them as it iterates up the chain.

[llvm-commits]

I'm OK working on doing that (I actually started there), but it looked like
I'd need to do a fair amount of work and it will slow me down... How badly
do you want this now, and how much do you want to put it on my critical
path to moving forward? I don't have strong opinions here, I'm jsut looking
for the fastest way to make forward progress.

• msg-9822-68.txt162 BDownload

[hfinkel]

In D12142#234840, @llvm-commits wrote:

I'm OK working on doing that (I actually started there), but it looked like
I'd need to do a fair amount of work and it will slow me down...

The statistics are important, let's think this through. We need a few things (bikeshedding aside):

struct AAStats {
  Statistic NumAliasQueries;
  Statistic NumNoAliasResults;
  ...

  // Statistics need a const char* description with a matching lifetime.
  std::string NumAliasQueriesName;
  std::string NumNoAliasResultsName;
  ...

  AAStats(const std::string &PassName) {
    NumAliasQueriesName = PassName + " 'alias' queries";
    NumNoAliasResultsName = PassName + " 'alias' queries resulting in 'NoAlias'";
    ...

    NumAliasQueries.construct(DEBUG_TYPE, NumAliasQueriesName.c_str());
    NumNoAliasResults.construct(DEBUG_TYPE, NumNoAliasResultsName.c_str());
    ...
  }
};

Then we need some map inside the aggregator, from pass name to these structs, or just keep an array of them in the same order as the AA chain. Regardless, it seems like AAResults::Concept needs a getName() function, or if we keep them in an array (probably better), then addAAResult might need to take a name parameter. Regardless, then we can put all of the stats updating into the AAResults methods.

Are there some tricky lifetime issues regarding the statistics objects relative to AAResults? Do these really need to live in the wrapper pass for the legacy pass manager and in AAManager for the new one?

How badly
do you want this now, and how much do you want to put it on my critical
path to moving forward? I don't have strong opinions here, I'm jsut looking
for the fastest way to make forward progress.

• msg-9822-68.txt162 BDownload

include/llvm/Analysis/BasicAliasAnalysis.h

BasicAAResult(BasicAAResult &&Arg)
       : AAResultBase(std::move(Arg)), DL(Arg.DL), AC(Arg.AC), DT(Arg.DT),
         LI(Arg.LI) {}
 
   /// Handle invalidation events from the new pass manager.
   ///
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &) { return false; }
 
-  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
-    assert(AliasCache.empty() && "AliasCache must be cleared after use!");
-    assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
-           "BasicAliasAnalysis doesn't support interprocedural queries.");
-    AliasResult Alias = aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr,
-                                   LocB.Size, LocB.AATags);
-    // AliasCache rarely has more than 1 or 2 elements, always use
-    // shrink_and_clear so it quickly returns to the inline capacity of the
-    // SmallDenseMap if it ever grows larger.
-    // FIXME: This should really be shrink_to_inline_capacity_and_clear().
-    AliasCache.shrink_and_clear();
-    VisitedPhiBBs.clear();
-    return Alias;
-  }
+  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc);
 
   ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2);
 
   /// Chases pointers until we find a (constant global) or not.
   bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal);
 

lib/Analysis/AliasAnalysis.cpp

 // it is very fast, and makes a nice clean default implementation.  Because it
 // handles lots of little corner cases, other, more complex, alias analysis
 // implementations may choose to rely on this pass to resolve these simple and
 // easy cases.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/CFLAliasAnalysis.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/ObjCARCAliasAnalysis.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Pass.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "aa"
+
 /// Allow disabling BasicAA from the AA results. This is particularly useful
 /// when testing to isolate a single AA implementation.
 static cl::opt<bool> DisableBasicAA("disable-basicaa", cl::Hidden,
                                     cl::init(false));
 
+STATISTIC(NumAliasQueries, "AA 'alias' queries");
+STATISTIC(NumNoAliasResults, "AA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumMayAliasResults, "AA 'alias' queries resulting in 'MayAlias'");
+STATISTIC(NumMustAliasResults, "AA 'alias' queries resulting in 'MustAlias'");
+STATISTIC(NumPartialAliasResults, "AA 'alias' queries resulting in 'PartialAlias'");
+STATISTIC(NumPointsToConstQueries, "AA 'pointsToConstantMemory' queries");
+STATISTIC(NumArgModRefInfoQueries, "AA argument 'ModRefInfo' queries");
+STATISTIC(NumModRefInfoQueries, "AA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults, "AA 'ModRefInfo' queries resulting in 'NoModRef'");
+STATISTIC(NumRefResults, "AA 'ModRefInfo' queries resulting in 'Ref'");
+STATISTIC(NumModResults, "AA 'ModRefInfo' queries resulting in 'Mod'");
+STATISTIC(NumModRefResults, "AA 'ModRefInfo' queries resulting in 'ModRef'");
+STATISTIC(NumModRefBehaviorQueries, "AA 'ModRefBehavior' queries");
+
 AAResults::AAResults(AAResults &&Arg) : AAs(std::move(Arg.AAs)) {
   for (auto &AA : AAs)
     AA->setAAResults(this);
 }
 
 AAResults &AAResults::operator=(AAResults &&Arg) {
   AAs = std::move(Arg.AAs);
   for (auto &AA : AAs)

 }
 
 //===----------------------------------------------------------------------===//
 // Default chaining methods
 //===----------------------------------------------------------------------===//
 
 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB) {
+  ++NumAliasQueries;
   for (const auto &AA : AAs) {
     auto Result = AA->alias(LocA, LocB);
-    if (Result != MayAlias)
+    if (Result != MayAlias) {
+      switch (Result) {
+      case NoAlias:
+        ++NumNoAliasResults;
+        break;
+      case MayAlias:
+        ++NumMayAliasResults;
+        break;
+      case MustAlias:
+        ++NumMustAliasResults;
+        break;
+      case PartialAlias:
+        ++NumPartialAliasResults;
+        break;
+      }
       return Result;
     }
+  }
   return MayAlias;
 }
 
 bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
                                        bool OrLocal) {
+  ++NumPointsToConstQueries;
   for (const auto &AA : AAs)
     if (AA->pointsToConstantMemory(Loc, OrLocal))
       return true;
 
   return false;
 }
 
 ModRefInfo AAResults::getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
   ModRefInfo Result = MRI_ModRef;
 
+  ++NumArgModRefInfoQueries;
   for (const auto &AA : AAs) {
     Result = ModRefInfo(Result & AA->getArgModRefInfo(CS, ArgIdx));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == MRI_NoModRef)
       return Result;
   }
 
if (auto CS = ImmutableCallSite(I)) {
     // defines, it must be clobbered by this location.
     const MemoryLocation DefLoc = MemoryLocation::get(I);
     if (getModRefInfo(Call, DefLoc) != MRI_NoModRef)
       return MRI_ModRef;
   }
   return MRI_NoModRef;
 }
 
+static void countModRefInfoResult(ModRefInfo MRI) {
+  switch (MRI) {
+  case MRI_NoModRef:
+    ++NumNoModRefResults;
+    break;
+  case MRI_Ref:
+    ++NumRefResults;
+    break;
+  case MRI_Mod:
+    ++NumModResults;
+    break;
+  case MRI_ModRef:
+    ++NumModRefResults;
+    break;
+  }
+}
+
 ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS,
                                     const MemoryLocation &Loc) {
   ModRefInfo Result = MRI_ModRef;
 
+  ++NumModRefInfoQueries;
   for (const auto &AA : AAs) {
     Result = ModRefInfo(Result & AA->getModRefInfo(CS, Loc));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == MRI_NoModRef)
-      return Result;
+      break;
   }
 
+  countModRefInfoResult(Result);
   return Result;
 }
 
 ModRefInfo AAResults::getModRefInfo(ImmutableCallSite CS1,
                                     ImmutableCallSite CS2) {
   ModRefInfo Result = MRI_ModRef;
 
+  ++NumModRefInfoQueries;
   for (const auto &AA : AAs) {
     Result = ModRefInfo(Result & AA->getModRefInfo(CS1, CS2));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == MRI_NoModRef)
-      return Result;
+      break;
   }
 
+  countModRefInfoResult(Result);
   return Result;
 }
 
 FunctionModRefBehavior AAResults::getModRefBehavior(ImmutableCallSite CS) {
   FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior;
 
+  ++NumModRefBehaviorQueries;
   for (const auto &AA : AAs) {
     Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(CS));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == FMRB_DoesNotAccessMemory)
       return Result;
   }
 
   return Result;
 }
 
 FunctionModRefBehavior AAResults::getModRefBehavior(const Function *F) {
   FunctionModRefBehavior Result = FMRB_UnknownModRefBehavior;
 
+  ++NumModRefBehaviorQueries;
   for (const auto &AA : AAs) {
     Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(F));
 
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == FMRB_DoesNotAccessMemory)
       return Result;
   }
 

lib/Analysis/BasicAliasAnalysis.cpp

 /// SearchLimitReached / SearchTimes shows how often the limit of
 /// to decompose GEPs is reached. It will affect the precision
 /// of basic alias analysis.
 #define DEBUG_TYPE "basicaa"
 STATISTIC(SearchLimitReached, "Number of times the limit to "
                               "decompose GEPs is reached");
 STATISTIC(SearchTimes, "Number of times a GEP is decomposed");
 
+STATISTIC(NumAliasQueries, "BasicAA 'alias' queries");
+STATISTIC(NumNoAliasResults, "BasicAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumMayAliasResults, "BasicAA 'alias' queries resulting in 'MayAlias'");
+STATISTIC(NumMustAliasResults, "BasicAA 'alias' queries resulting in 'MustAlias'");
+STATISTIC(NumPartialAliasResults, "BasicAA 'alias' queries resulting in 'PartialAlias'");
+STATISTIC(NumPointsToConstQueries, "BasicAA 'pointsToConstantMemory' queries");
+STATISTIC(NumArgModRefInfoQueries, "BasicAA argument 'ModRefInfo' queries");
+STATISTIC(NumModRefInfoQueries, "BasicAA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults, "BasicAA 'ModRefInfo' queries resulting in 'NoModRef'");
+STATISTIC(NumModRefBehaviorQueries, "BasicAA 'ModRefBehavior' queries");
+
 /// Cutoff after which to stop analysing a set of phi nodes potentially involved
 /// in a cycle. Because we are analysing 'through' phi nodes we need to be
 /// careful with value equivalence. We use reachability to make sure a value
 /// cannot be involved in a cycle.
 const unsigned MaxNumPhiBBsValueReachabilityCheck = 20;
 
 // The max limit of the search depth in DecomposeGEPExpression() and
 // GetUnderlyingObject(), both functions need to use the same search
/*static*/ const Value *BasicAAResult::DecomposeGEPExpression(
   } while (--MaxLookup);
 
   // If the chain of expressions is too deep, just return early.
   MaxLookupReached = true;
   SearchLimitReached++;
   return V;
 }
 
+AliasResult BasicAAResult::alias(const MemoryLocation &LocA,
+                                 const MemoryLocation &LocB) {
+  ++NumAliasQueries;
+  assert(AliasCache.empty() && "AliasCache must be cleared after use!");
+  assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
+         "BasicAliasAnalysis doesn't support interprocedural queries.");
+  AliasResult Alias = aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr,
+                                 LocB.Size, LocB.AATags);
+  switch (Alias) {
+  case NoAlias:
+    ++NumNoAliasResults;
+    break;
+  case MustAlias:
+    ++NumMustAliasResults;
+    break;
+  case PartialAlias:
+    ++NumPartialAliasResults;
+    break;
+  case MayAlias:
+    ++NumMayAliasResults;
+    break;
+  }
+
+  // AliasCache rarely has more than 1 or 2 elements, always use
+  // shrink_and_clear so it quickly returns to the inline capacity of the
+  // SmallDenseMap if it ever grows larger.
+  // FIXME: This should really be shrink_to_inline_capacity_and_clear().
+  AliasCache.shrink_and_clear();
+  VisitedPhiBBs.clear();
+  return Alias;
+}
+
 /// Returns whether the given pointer value points to memory that is local to
 /// the function, with global constants being considered local to all
 /// functions.
 bool BasicAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
                                            bool OrLocal) {
   assert(Visited.empty() && "Visited must be cleared after use!");
+  ++NumPointsToConstQueries;
 
   unsigned MaxLookup = 8;
   SmallVector<const Value *, 16> Worklist;
   Worklist.push_back(Loc.Ptr);
   do {
     const Value *V = GetUnderlyingObject(Worklist.pop_back_val(), DL);
     if (!Visited.insert(V).second) {
       Visited.clear();
if (!MemsetType->isVarArg() && MemsetType->getNumParams() == 3 &&
       return true;
   }
 
   return false;
 }
 
 /// Returns the behavior when calling the given call site.
 FunctionModRefBehavior BasicAAResult::getModRefBehavior(ImmutableCallSite CS) {
+  ++NumModRefBehaviorQueries;
   if (CS.doesNotAccessMemory())
     // Can't do better than this.
     return FMRB_DoesNotAccessMemory;
 
   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
 
   // If the callsite knows it only reads memory, don't return worse
   // than that.
   if (CS.onlyReadsMemory())
     Min = FMRB_OnlyReadsMemory;
 
   if (CS.onlyAccessesArgMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
 
   // The AAResultBase base class has some smarts, lets use them.
   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(CS) & Min);
 }
 
 /// Returns the behavior when calling the given function. For use when the call
 /// site is not known.
 FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) {
+  ++NumModRefBehaviorQueries;
   // If the function declares it doesn't access memory, we can't do better.
   if (F->doesNotAccessMemory())
     return FMRB_DoesNotAccessMemory;
 
   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
 
   // If the function declares it only reads memory, go with that.
   if (F->onlyReadsMemory())
     Min = FMRB_OnlyReadsMemory;
 
   if (F->onlyAccessesArgMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesArgumentPointees);
 
   if (isMemsetPattern16(F, TLI))
     Min = FMRB_OnlyAccessesArgumentPointees;
 
   // Otherwise be conservative.
   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(F) & Min);
 }
 
 ModRefInfo BasicAAResult::getArgModRefInfo(ImmutableCallSite CS,
                                            unsigned ArgIdx) {
+  ++NumArgModRefInfoQueries;
   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction()))
     switch (II->getIntrinsicID()) {
     default:
       break;
     case Intrinsic::memset:
     case Intrinsic::memcpy:
     case Intrinsic::memmove:
       assert((ArgIdx == 0 || ArgIdx == 1) &&

 ///
 /// Since we only look at local properties of this function, we really can't
 /// say much about this query.  We do, however, use simple "address taken"
 /// analysis on local objects.
 ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS,
                                         const MemoryLocation &Loc) {
   assert(notDifferentParent(CS.getInstruction(), Loc.Ptr) &&
          "AliasAnalysis query involving multiple functions!");
+  ++NumModRefInfoQueries;
 
   const Value *Object = GetUnderlyingObject(Loc.Ptr, DL);
 
   // If this is a tail call and Loc.Ptr points to a stack location, we know that
   // the tail call cannot access or modify the local stack.
   // We cannot exclude byval arguments here; these belong to the caller of
   // the current function not to the current function, and a tail callee
   // may reference them.
   if (isa<AllocaInst>(Object))
     if (const CallInst *CI = dyn_cast<CallInst>(CS.getInstruction()))
-      if (CI->isTailCall())
+      if (CI->isTailCall()) {
+        ++NumNoModRefResults;
         return MRI_NoModRef;
+      }
 
   // If the pointer is to a locally allocated object that does not escape,
   // then the call can not mod/ref the pointer unless the call takes the pointer
   // as an argument, and itself doesn't capture it.
   if (!isa<Constant>(Object) && CS.getInstruction() != Object &&
       isNonEscapingLocalObject(Object)) {
     bool PassedAsArg = false;
     unsigned ArgNo = 0;
for (ImmutableCallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
           AAR ? AAR->alias(MemoryLocation(*CI), MemoryLocation(Object))
               : alias(MemoryLocation(*CI), MemoryLocation(Object));
       if (AR) {
         PassedAsArg = true;
         break;
       }
     }
 
-    if (!PassedAsArg)
+    if (!PassedAsArg) {
+      ++NumNoModRefResults;
       return MRI_NoModRef;
     }
+  }
 
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
-  if (isAssumeIntrinsic(CS))
+  if (isAssumeIntrinsic(CS)) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS, Loc);
 }
 
 ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1,
                                         ImmutableCallSite CS2) {
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
-  if (isAssumeIntrinsic(CS1) || isAssumeIntrinsic(CS2))
+  if (isAssumeIntrinsic(CS1) || isAssumeIntrinsic(CS2)) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS1, CS2);
 }
 
 /// Provide ad-hoc rules to disambiguate accesses through two GEP operators,
 /// both having the exact same pointer operand.
 static AliasResult aliasSameBasePointerGEPs(const GEPOperator *GEP1,

lib/Analysis/GlobalsModRef.cpp

 
 STATISTIC(NumNonAddrTakenGlobalVars,
           "Number of global vars without address taken");
 STATISTIC(NumNonAddrTakenFunctions,"Number of functions without address taken");
 STATISTIC(NumNoMemFunctions, "Number of functions that do not access memory");
 STATISTIC(NumReadMemFunctions, "Number of functions that only read memory");
 STATISTIC(NumIndirectGlobalVars, "Number of indirect global objects");
 
+STATISTIC(NumAliasQueries, "GlobalsAA 'alias' queries");
+STATISTIC(NumNoAliasResults,
+          "GlobalsAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumModRefInfoQueries, "GlobalsAA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults,
+          "GlobalsAA 'ModRefInfo' queries resulting in 'NoModRef'");
+STATISTIC(NumModRefBehaviorQueries, "GlobalsAA 'ModRefBehavior' queries");
+
 // An option to enable unsafe alias results from the GlobalsModRef analysis.
 // When enabled, GlobalsModRef will provide no-alias results which in extremely
 // rare cases may not be conservatively correct. In particular, in the face of
 // transforms which cause assymetry between how effective GetUnderlyingObject
 // is for two pointers, it may produce incorrect results.
 //
 // These unsafe results have been returned by GMR for many years without
 // causing significant issues in the wild and so we provide a mechanism to
void GlobalsAAResult::DeletionCallbackHandle::deleted() {
   // And clear out the handle.
   setValPtr(nullptr);
   GAR.Handles.erase(I);
   // This object is now destroyed!
 }
 
 FunctionModRefBehavior GlobalsAAResult::getModRefBehavior(const Function *F) {
   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
+  ++NumModRefBehaviorQueries;
 
   if (FunctionInfo *FI = getFunctionInfo(F)) {
     if (FI->getModRefInfo() == MRI_NoModRef)
       Min = FMRB_DoesNotAccessMemory;
     else if ((FI->getModRefInfo() & MRI_Mod) == 0)
       Min = FMRB_OnlyReadsMemory;
   }
 
   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(F) & Min);
 }
 
 FunctionModRefBehavior
 GlobalsAAResult::getModRefBehavior(ImmutableCallSite CS) {
   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
+  ++NumModRefBehaviorQueries;
 
   if (const Function *F = CS.getCalledFunction())
     if (FunctionInfo *FI = getFunctionInfo(F)) {
       if (FI->getModRefInfo() == MRI_NoModRef)
         Min = FMRB_DoesNotAccessMemory;
       else if ((FI->getModRefInfo() & MRI_Mod) == 0)
         Min = FMRB_OnlyReadsMemory;
     }
bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
   return true;
 }
 
 /// alias - If one of the pointers is to a global that we are tracking, and the
 /// other is some random pointer, we know there cannot be an alias, because the
 /// address of the global isn't taken.
 AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
                                    const MemoryLocation &LocB) {
+  ++NumAliasQueries;
+
   // Get the base object these pointers point to.
   const Value *UV1 = GetUnderlyingObject(LocA.Ptr, DL);
   const Value *UV2 = GetUnderlyingObject(LocB.Ptr, DL);
 
   // If either of the underlying values is a global, they may be non-addr-taken
   // globals, which we can answer queries about.
   const GlobalValue *GV1 = dyn_cast<GlobalValue>(UV1);
   const GlobalValue *GV2 = dyn_cast<GlobalValue>(UV2);
   if (GV1 || GV2) {
     // If the global's address is taken, pretend we don't know it's a pointer to
     // the global.
     if (GV1 && !NonAddressTakenGlobals.count(GV1))
       GV1 = nullptr;
     if (GV2 && !NonAddressTakenGlobals.count(GV2))
       GV2 = nullptr;
 
     // If the two pointers are derived from two different non-addr-taken
     // globals we know these can't alias.
-    if (GV1 && GV2 && GV1 != GV2)
+    if (GV1 && GV2 && GV1 != GV2) {
+      ++NumNoAliasResults;
       return NoAlias;
+    }
 
     // If one is and the other isn't, it isn't strictly safe but we can fake
     // this result if necessary for performance. This does not appear to be
     // a common problem in practice.
     if (EnableUnsafeGlobalsModRefAliasResults)
-      if ((GV1 || GV2) && GV1 != GV2)
+      if ((GV1 || GV2) && GV1 != GV2) {
+      ++NumNoAliasResults;
         return NoAlias;
+      }
 
     // Check for a special case where a non-escaping global can be used to
     // conclude no-alias.
     if ((GV1 || GV2) && GV1 != GV2) {
       const GlobalValue *GV = GV1 ? GV1 : GV2;
       const Value *UV = GV1 ? UV2 : UV1;
-      if (isNonEscapingGlobalNoAlias(GV, UV))
+      if (isNonEscapingGlobalNoAlias(GV, UV)) {
+        ++NumNoAliasResults;
         return NoAlias;
       }
+    }
 
     // Otherwise if they are both derived from the same addr-taken global, we
     // can't know the two accesses don't overlap.
   }
 
   // These pointers may be based on the memory owned by an indirect global.  If
   // so, we may be able to handle this.  First check to see if the base pointer
   // is a direct load from an indirect global.
AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
   if (!GV1)
     GV1 = AllocsForIndirectGlobals.lookup(UV1);
   if (!GV2)
     GV2 = AllocsForIndirectGlobals.lookup(UV2);
 
   // Now that we know whether the two pointers are related to indirect globals,
   // use this to disambiguate the pointers. If the pointers are based on
   // different indirect globals they cannot alias.
-  if (GV1 && GV2 && GV1 != GV2)
+  if (GV1 && GV2 && GV1 != GV2) {
+    ++NumNoAliasResults;
     return NoAlias;
+  }
 
   // If one is based on an indirect global and the other isn't, it isn't
   // strictly safe but we can fake this result if necessary for performance.
   // This does not appear to be a common problem in practice.
   if (EnableUnsafeGlobalsModRefAliasResults)
-    if ((GV1 || GV2) && GV1 != GV2)
+    if ((GV1 || GV2) && GV1 != GV2) {
+      ++NumNoAliasResults;
       return NoAlias;
+    }
 
   return AAResultBase::alias(LocA, LocB);
 }
 
 ModRefInfo GlobalsAAResult::getModRefInfo(ImmutableCallSite CS,
                                           const MemoryLocation &Loc) {
   unsigned Known = MRI_ModRef;
+  ++NumModRefInfoQueries;
 
   // If we are asking for mod/ref info of a direct call with a pointer to a
   // global we are tracking, return information if we have it.
   if (const GlobalValue *GV =
           dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))
     if (GV->hasLocalLinkage())
       if (const Function *F = CS.getCalledFunction())
         if (NonAddressTakenGlobals.count(GV))
           if (const FunctionInfo *FI = getFunctionInfo(F))
             Known = FI->getModRefInfoForGlobal(*GV);
 
-  if (Known == MRI_NoModRef)
+  if (Known == MRI_NoModRef) {
+    ++NumNoModRefResults;
     return MRI_NoModRef; // No need to query other mod/ref analyses
+  }
   return ModRefInfo(Known & AAResultBase::getModRefInfo(CS, Loc));
 }
 
 GlobalsAAResult::GlobalsAAResult(const DataLayout &DL,
                                  const TargetLibraryInfo &TLI)
     : AAResultBase(TLI), DL(DL) {}
 
 GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg)

lib/Analysis/ObjCARCAliasAnalysis.cpp

 /// behavior-preserving may break these assumptions.
 ///
 /// TODO: Theoretically we could check for dependencies between objc_* calls
 /// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ObjCARCAliasAnalysis.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassAnalysisSupport.h"
 #include "llvm/PassSupport.h"
 
 #define DEBUG_TYPE "objc-arc-aa"
 
 using namespace llvm;
 using namespace llvm::objcarc;
 
+STATISTIC(NumAliasQueries, "ObjCARCAA 'alias' queries");
+STATISTIC(NumNoAliasResults,
+          "ObjCARCAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumMustAliasResults,
+          "ObjCARCAA 'alias' queries resulting in 'MustAlias'");
+STATISTIC(NumPartialAliasResults,
+          "ObjCARCAA 'alias' queries resulting in 'PartialAlias'");
+STATISTIC(NumPointsToConstQueries,
+          "ObjCARCAA 'pointsToConstantMemory' queries");
+STATISTIC(NumModRefInfoQueries, "ObjCARCAA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults,
+          "ObjCARCAA 'ModRefInfo' queries resulting in 'NoModRef'");
+STATISTIC(NumModRefBehaviorQueries, "ObjCARCAA 'ModRefBehavior' queries");
+
 AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA,
                                    const MemoryLocation &LocB) {
   if (!EnableARCOpts)
     return AAResultBase::alias(LocA, LocB);
+  ++NumAliasQueries;
 
   // First, strip off no-ops, including ObjC-specific no-ops, and try making a
   // precise alias query.
   const Value *SA = GetRCIdentityRoot(LocA.Ptr);
   const Value *SB = GetRCIdentityRoot(LocB.Ptr);
   AliasResult Result =
       AAResultBase::alias(MemoryLocation(SA, LocA.Size, LocA.AATags),
                           MemoryLocation(SB, LocB.Size, LocB.AATags));
-  if (Result != MayAlias)
+  if (Result != MayAlias) {
+    if (Result == NoAlias)
+      ++NumNoAliasResults;
+    else if (Result == MustAlias)
+      ++NumMustAliasResults;
+    else if (Result == PartialAlias)
+      ++NumPartialAliasResults;
     return Result;
+  }
 
   // If that failed, climb to the underlying object, including climbing through
   // ObjC-specific no-ops, and try making an imprecise alias query.
   const Value *UA = GetUnderlyingObjCPtr(SA, DL);
   const Value *UB = GetUnderlyingObjCPtr(SB, DL);
   if (UA != SA || UB != SB) {
     Result = AAResultBase::alias(MemoryLocation(UA), MemoryLocation(UB));
     // We can't use MustAlias or PartialAlias results here because
     // GetUnderlyingObjCPtr may return an offsetted pointer value.
-    if (Result == NoAlias)
+    if (Result == NoAlias) {
+      ++NumNoAliasResults;
       return NoAlias;
     }
+  }
 
   // If that failed, fail. We don't need to chain here, since that's covered
   // by the earlier precise query.
   return MayAlias;
 }
 
 bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
                                              bool OrLocal) {
   if (!EnableARCOpts)
     return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
+  ++NumPointsToConstQueries;
 
   // First, strip off no-ops, including ObjC-specific no-ops, and try making
   // a precise alias query.
   const Value *S = GetRCIdentityRoot(Loc.Ptr);
   if (AAResultBase::pointsToConstantMemory(
           MemoryLocation(S, Loc.Size, Loc.AATags), OrLocal))
     return true;
 
   // If that failed, climb to the underlying object, including climbing through
   // ObjC-specific no-ops, and try making an imprecise alias query.
   const Value *U = GetUnderlyingObjCPtr(S, DL);
   if (U != S)
     return AAResultBase::pointsToConstantMemory(MemoryLocation(U), OrLocal);
 
   // If that failed, fail. We don't need to chain here, since that's covered
   // by the earlier precise query.
   return false;
 }
 
 FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
   if (!EnableARCOpts)
     return AAResultBase::getModRefBehavior(F);
+  ++NumModRefBehaviorQueries;
 
   switch (GetFunctionClass(F)) {
   case ARCInstKind::NoopCast:
     return FMRB_DoesNotAccessMemory;
   default:
     break;
   }
 
   return AAResultBase::getModRefBehavior(F);
 }
 
 ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS,
                                           const MemoryLocation &Loc) {
   if (!EnableARCOpts)
     return AAResultBase::getModRefInfo(CS, Loc);
+  ++NumModRefInfoQueries;
 
   switch (GetBasicARCInstKind(CS.getInstruction())) {
   case ARCInstKind::Retain:
   case ARCInstKind::RetainRV:
   case ARCInstKind::Autorelease:
   case ARCInstKind::AutoreleaseRV:
   case ARCInstKind::NoopCast:
   case ARCInstKind::AutoreleasepoolPush:
   case ARCInstKind::FusedRetainAutorelease:
   case ARCInstKind::FusedRetainAutoreleaseRV:
     // These functions don't access any memory visible to the compiler.
     // Note that this doesn't include objc_retainBlock, because it updates
     // pointers when it copies block data.
+    ++NumNoModRefResults;
     return MRI_NoModRef;
   default:
     break;
   }
 
   return AAResultBase::getModRefInfo(CS, Loc);
 }
 

lib/Analysis/ScalarEvolutionAliasAnalysis.cpp

 // dependencies between different iterations.
 //
 // ScalarEvolution has a more complete understanding of pointer arithmetic
 // than BasicAliasAnalysis' collection of ad-hoc analyses.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "scevaa"
+STATISTIC(NumAliasQueries, "SCEVAA 'alias' queries");
+STATISTIC(NumNoAliasResults, "SCEVAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumMustAliasResults,
+          "SCEVAA 'alias' queries resulting in 'MustAlias'");
+
 AliasResult SCEVAAResult::alias(const MemoryLocation &LocA,
                                 const MemoryLocation &LocB) {
+  ++NumAliasQueries;
+
   // If either of the memory references is empty, it doesn't matter what the
   // pointer values are. This allows the code below to ignore this special
   // case.
-  if (LocA.Size == 0 || LocB.Size == 0)
+  if (LocA.Size == 0 || LocB.Size == 0) {
+    ++NumNoAliasResults;
     return NoAlias;
+  }
 
   // This is SCEVAAResult. Get the SCEVs!
   const SCEV *AS = SE.getSCEV(const_cast<Value *>(LocA.Ptr));
   const SCEV *BS = SE.getSCEV(const_cast<Value *>(LocB.Ptr));
 
   // If they evaluate to the same expression, it's a MustAlias.
-  if (AS == BS)
+  if (AS == BS) {
+    ++NumMustAliasResults;
     return MustAlias;
+  }
 
   // If something is known about the difference between the two addresses,
   // see if it's enough to prove a NoAlias.
   if (SE.getEffectiveSCEVType(AS->getType()) ==
       SE.getEffectiveSCEVType(BS->getType())) {
     unsigned BitWidth = SE.getTypeSizeInBits(AS->getType());
     APInt ASizeInt(BitWidth, LocA.Size);
     APInt BSizeInt(BitWidth, LocB.Size);
 
     // Compute the difference between the two pointers.
     const SCEV *BA = SE.getMinusSCEV(BS, AS);
 
     // Test whether the difference is known to be great enough that memory of
     // the given sizes don't overlap. This assumes that ASizeInt and BSizeInt
     // are non-zero, which is special-cased above.
     if (ASizeInt.ule(SE.getUnsignedRange(BA).getUnsignedMin()) &&
-        (-BSizeInt).uge(SE.getUnsignedRange(BA).getUnsignedMax()))
+        (-BSizeInt).uge(SE.getUnsignedRange(BA).getUnsignedMax())) {
+      ++NumNoAliasResults;
       return NoAlias;
+    }
 
     // Folding the subtraction while preserving range information can be tricky
     // (because of INT_MIN, etc.); if the prior test failed, swap AS and BS
     // and try again to see if things fold better that way.
 
     // Compute the difference between the two pointers.
     const SCEV *AB = SE.getMinusSCEV(AS, BS);
 
     // Test whether the difference is known to be great enough that memory of
     // the given sizes don't overlap. This assumes that ASizeInt and BSizeInt
     // are non-zero, which is special-cased above.
     if (BSizeInt.ule(SE.getUnsignedRange(AB).getUnsignedMin()) &&
-        (-ASizeInt).uge(SE.getUnsignedRange(AB).getUnsignedMax()))
+        (-ASizeInt).uge(SE.getUnsignedRange(AB).getUnsignedMax())) {
+      ++NumNoAliasResults;
       return NoAlias;
     }
 
+  }
+
   // If ScalarEvolution can find an underlying object, form a new query.
   // The correctness of this depends on ScalarEvolution not recognizing
   // inttoptr and ptrtoint operators.
   Value *AO = GetBaseValue(AS);
   Value *BO = GetBaseValue(BS);
   if ((AO && AO != LocA.Ptr) || (BO && BO != LocB.Ptr))
     if (alias(MemoryLocation(AO ? AO : LocA.Ptr,
                              AO ? +MemoryLocation::UnknownSize : LocA.Size,
                              AO ? AAMDNodes() : LocA.AATags),
               MemoryLocation(BO ? BO : LocB.Ptr,
                              BO ? +MemoryLocation::UnknownSize : LocB.Size,
-                             BO ? AAMDNodes() : LocB.AATags)) == NoAlias)
+                             BO ? AAMDNodes() : LocB.AATags)) == NoAlias) {
+      ++NumNoAliasResults;
       return NoAlias;
+    }
 
   // Forward the query to the next analysis.
   return AAResultBase::alias(LocA, LocB);
 }
 
 /// Given an expression, try to find a base value.
 ///
 /// Returns null if none was found.

lib/Analysis/ScopedNoAliasAA.cpp

 // has a set of noalias scopes in some domain that is superset of the alias
 // scopes in that domain of some other instruction, then the two memory
 // accesses are assumed not to alias.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "scoped-noalias"
+
 // A handy option for disabling scoped no-alias functionality. The same effect
 // can also be achieved by stripping the associated metadata tags from IR, but
 // this option is sometimes more convenient.
 static cl::opt<bool> EnableScopedNoAlias("enable-scoped-noalias",
                                          cl::init(true));
 
+STATISTIC(NumAliasQueries, "ScopedNoAliasAA 'alias' queries");
+STATISTIC(NumNoAliasResults,
+          "ScopedNoAliasAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumModRefInfoQueries, "ScopedNoAliasAA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults,
+          "ScopedNoAliasAA 'ModRefInfo' queries resulting in 'NoModRef'");
+
 namespace {
 /// AliasScopeNode - This is a simple wrapper around an MDNode which provides
 /// a higher-level interface by hiding the details of how alias analysis
 /// information is encoded in its operands.
 class AliasScopeNode {
   const MDNode *Node;
 
 public:
public:
   }
 };
 } // End of anonymous namespace
 
 AliasResult ScopedNoAliasAAResult::alias(const MemoryLocation &LocA,
                                          const MemoryLocation &LocB) {
   if (!EnableScopedNoAlias)
     return AAResultBase::alias(LocA, LocB);
+  ++NumAliasQueries;
 
   // Get the attached MDNodes.
   const MDNode *AScopes = LocA.AATags.Scope, *BScopes = LocB.AATags.Scope;
 
   const MDNode *ANoAlias = LocA.AATags.NoAlias, *BNoAlias = LocB.AATags.NoAlias;
 
-  if (!mayAliasInScopes(AScopes, BNoAlias))
+  if (!mayAliasInScopes(AScopes, BNoAlias)) {
+    ++NumNoAliasResults;
     return NoAlias;
+  }
 
-  if (!mayAliasInScopes(BScopes, ANoAlias))
+  if (!mayAliasInScopes(BScopes, ANoAlias)) {
+    ++NumNoAliasResults;
     return NoAlias;
+  }
 
   // If they may alias, chain to the next AliasAnalysis.
   return AAResultBase::alias(LocA, LocB);
 }
 
 ModRefInfo ScopedNoAliasAAResult::getModRefInfo(ImmutableCallSite CS,
                                                 const MemoryLocation &Loc) {
   if (!EnableScopedNoAlias)
     return AAResultBase::getModRefInfo(CS, Loc);
+  ++NumModRefInfoQueries;
 
   if (!mayAliasInScopes(Loc.AATags.Scope, CS.getInstruction()->getMetadata(
-                                              LLVMContext::MD_noalias)))
+                                              LLVMContext::MD_noalias))) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   if (!mayAliasInScopes(
           CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
-          Loc.AATags.NoAlias))
+          Loc.AATags.NoAlias)) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   return AAResultBase::getModRefInfo(CS, Loc);
 }
 
 ModRefInfo ScopedNoAliasAAResult::getModRefInfo(ImmutableCallSite CS1,
                                                 ImmutableCallSite CS2) {
   if (!EnableScopedNoAlias)
     return AAResultBase::getModRefInfo(CS1, CS2);
+  ++NumModRefInfoQueries;
 
   if (!mayAliasInScopes(
           CS1.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
-          CS2.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
+          CS2.getInstruction()->getMetadata(LLVMContext::MD_noalias))) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   if (!mayAliasInScopes(
           CS2.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
-          CS1.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
+          CS1.getInstruction()->getMetadata(LLVMContext::MD_noalias))) {
+    ++NumNoModRefResults;
     return MRI_NoModRef;
+  }
 
   return AAResultBase::getModRefInfo(CS1, CS2);
 }
 
 void ScopedNoAliasAAResult::collectMDInDomain(
     const MDNode *List, const MDNode *Domain,
     SmallPtrSetImpl<const MDNode *> &Nodes) const {
   for (unsigned i = 0, ie = List->getNumOperands(); i != ie; ++i)

lib/Analysis/TypeBasedAliasAnalysis.cpp

 // aliases, so struct assignments must use conservative TBAA nodes. There's
 // no scheme for attaching metadata to @llvm.memcpy yet either.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "tbaa"
+
 // A handy option for disabling TBAA functionality. The same effect can also be
 // achieved by stripping the !tbaa tags from IR, but this option is sometimes
 // more convenient.
 static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true));
 
+STATISTIC(NumAliasQueries, "TBAA 'alias' queries");
+STATISTIC(NumNoAliasResults, "TBAA 'alias' queries resulting in 'NoAlias'");
+STATISTIC(NumPointsToConstQueries, "TBAA 'pointsToConstantMemory' queries");
+STATISTIC(NumModRefInfoQueries, "TBAA 'ModRefInfo' queries");
+STATISTIC(NumNoModRefResults,
+          "TBAA 'ModRefInfo' queries resulting in 'NoModRef'");
+STATISTIC(NumModRefBehaviorQueries, "TBAA 'ModRefBehavior' queries");
+
 namespace {
 /// TBAANode - This is a simple wrapper around an MDNode which provides a
 /// higher-level interface by hiding the details of how alias analysis
 /// information is encoded in its operands.
 class TBAANode {
   const MDNode *Node;
 
 public:
static bool isStructPathTBAA(const MDNode *MD) {
   // a TBAA tag.
   return isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
 }
 
 AliasResult TypeBasedAAResult::alias(const MemoryLocation &LocA,
                                      const MemoryLocation &LocB) {
   if (!EnableTBAA)
     return AAResultBase::alias(LocA, LocB);
+  ++NumAliasQueries;
 
   // Get the attached MDNodes. If either value lacks a tbaa MDNode, we must
   // be conservative.
   const MDNode *AM = LocA.AATags.TBAA;
   if (!AM)
     return AAResultBase::alias(LocA, LocB);
   const MDNode *BM = LocB.AATags.TBAA;
   if (!BM)
     return AAResultBase::alias(LocA, LocB);
 
   // If they may alias, chain to the next AliasAnalysis.
   if (Aliases(AM, BM))
     return AAResultBase::alias(LocA, LocB);
 
   // Otherwise return a definitive result.
+  ++NumNoAliasResults;
   return NoAlias;
 }
 
 bool TypeBasedAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
                                                bool OrLocal) {
   if (!EnableTBAA)
     return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
+  ++NumPointsToConstQueries;
 
   const MDNode *M = Loc.AATags.TBAA;
   if (!M)
     return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
 
   // If this is an "immutable" type, we can assume the pointer is pointing
   // to constant memory.
   if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) ||
       (isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable()))
     return true;
 
   return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
 }
 
 FunctionModRefBehavior
 TypeBasedAAResult::getModRefBehavior(ImmutableCallSite CS) {
   if (!EnableTBAA)
     return AAResultBase::getModRefBehavior(CS);
+  ++NumModRefBehaviorQueries;
 
   FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
 
   // If this is an "immutable" type, we can assume the call doesn't write
   // to memory.
   if (const MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
     if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) ||
         (isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable()))
       Min = FMRB_OnlyReadsMemory;
 
   return FunctionModRefBehavior(AAResultBase::getModRefBehavior(CS) & Min);
 }
 
 FunctionModRefBehavior TypeBasedAAResult::getModRefBehavior(const Function *F) {
   // Functions don't have metadata. Just chain to the next implementation.
   return AAResultBase::getModRefBehavior(F);
 }
 
 ModRefInfo TypeBasedAAResult::getModRefInfo(ImmutableCallSite CS,
                                             const MemoryLocation &Loc) {
   if (!EnableTBAA)
     return AAResultBase::getModRefInfo(CS, Loc);
+  ++NumModRefInfoQueries;
 
   if (const MDNode *L = Loc.AATags.TBAA)
     if (const MDNode *M =
             CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
-      if (!Aliases(L, M))
+      if (!Aliases(L, M)) {
+        ++NumNoModRefResults;
         return MRI_NoModRef;
+      }
 
   return AAResultBase::getModRefInfo(CS, Loc);
 }
 
 ModRefInfo TypeBasedAAResult::getModRefInfo(ImmutableCallSite CS1,
                                             ImmutableCallSite CS2) {
   if (!EnableTBAA)
     return AAResultBase::getModRefInfo(CS1, CS2);
+  ++NumModRefInfoQueries;
 
   if (const MDNode *M1 =
           CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
     if (const MDNode *M2 =
             CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
-      if (!Aliases(M1, M2))
+      if (!Aliases(M1, M2)) {
+        ++NumNoModRefResults;
         return MRI_NoModRef;
+      }
 
   return AAResultBase::getModRefInfo(CS1, CS2);
 }
 
 bool MDNode::isTBAAVtableAccess() const {
   if (!isStructPathTBAA(this)) {
     if (getNumOperands() < 1)
       return false;