[ThinLTO] WIP Tracking of per-call mod ref info

[tejohnson]

Summary

Draft changes to add per-call memory access information to the
in-memory index. The ReadNone and ReadOnly function attributes
are changed to only reflect non-call instructions.

This will enable more effective propagation of those attributes
during the thin link. For example, if the callee is marked as
ReadNone during the bottom up SCC propagation, then calls to
it that had conservative mod ref (indicating that they MayWrite)
can be changed to ReadNone. I.e the new function attribute will
be the max (most conservative) of its recorded attribute computed
without considering its calls, and the read/write attribute on
the call, where the call's read/write attribute is computed by
combining (taking the most conservative of) the read/write attribute
recorded in the index along that edge and the function attribute
recorded for it in the index (after earlier bottom up propagation).

Some notes:

• I noted that we should probably rename the ReadNone and

ReadOnly attributes to reflect the fact that they don't include
calls. However, after the bottom up propagation during the thin
link they will in fact include call behavior (as described above).
Not sure how to accurately name these attributes

• I only added the changes in the in-memory index, the Bitcode

reader and writer support still needs to be added.

• I left in some tracing messages emitted during ModuleSummaryIndex

building.

• I had to split out some of the FunctionAttr handling and moved it

to some files in lib/Analysis so that it could be accessed by
the ModuleSummaryIndex builder which lives in lib/Analysis. I also
constified the Function parameter.

• I'm not really happy with the way I hacked up checkFunctionMemoryAccess.

If the new map pointer is non-null, it puts the info for each call site
in the map rather than affecting the return value. I feel this could
probably be refactored in a cleaner way.

• I have defaulted the new CalleeInfo field (for the call edges) to

the least conservative setting, so that I can update it by taking
the max. This should be ok since the only time we wouldn't update it
is if it has no calls or we don't have an AAResult object passed
into the summary builder. In that latter case, we set the function
attributes in the index based on the function attributes on the
Function, which would already be conservative, so it should be ok.
But it would probably be clearer to have an "Unknown" setting and
init to that.

[davide]

I'm OK with the direction, Teresa, thanks.
If Charles wants to pursue this path before the GSoC ends, that will be great.

[ncharlie]

In D36910#846491, @davide wrote:

I'm OK with the direction, Teresa, thanks.
If Charles wants to pursue this path before the GSoC ends, that will be great.

Yeah, I definitely like this approach better than what I had written. I can address the TODOs and clean it up a bit on Monday?

[tejohnson]

In D36910#846688, @ncharlie wrote:

In D36910#846491, @davide wrote:

I'm OK with the direction, Teresa, thanks.
If Charles wants to pursue this path before the GSoC ends, that will be great.

Yeah, I definitely like this approach better than what I had written. I can address the TODOs and clean it up a bit on Monday?

Sure! I may add a couple comments before then with some cleanup ideas.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

300

What about "LocalReadNone"? It reminds me the "local_unnamed_addr" attribute.

[ncharlie]

I added bitcode read/write support and updated all the tests so they use the new bitcode. I was planning on waiting for a bit more feedback on this patch (and updating mine with the requested changes), but I can post mine whenever you want to move the discussion to llvm-commits.

[tejohnson]

In D36910#847941, @ncharlie wrote:

I added bitcode read/write support and updated all the tests so they use the new bitcode. I was planning on waiting for a bit more feedback on this patch (and updating mine with the requested changes), but I can post mine whenever you want to move the discussion to llvm-commits.

Awesome! Why don't you go ahead and post it to llvm-commits and we can continue with a more formal review. Thanks.

include/llvm/Analysis/FunctionAttrsAnalysis.h

+//===-- FunctionAttrs.h - Compute function attrs --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// Provides analysis for computing function attributes
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_FUNCTIONATTRSANALYSIS_H
+#define LLVM_ANALYSIS_FUNCTIONATTRSANALYSIS_H
+
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+
+namespace llvm {
+
+class AAResults;
+
+/// The three kinds of memory access relevant to 'readonly' and
+/// 'readnone' attributes.
+enum MemoryAccessKind { MAK_ReadNone = 0, MAK_ReadOnly = 1, MAK_MayWrite = 2 };
+
+typedef SmallSetVector<Function *, 8> SCCNodeSet;
+
+/// Returns the memory access properties of this copy of the function.
+MemoryAccessKind computeFunctionBodyMemoryAccess(
+    const Function &F, AAResults &AAR,
+    DenseMap<const Function *, ModRefInfo> *CSModRefMap = nullptr);
+
+MemoryAccessKind
+checkFunctionMemoryAccess(const Function &F, bool ThisBody, AAResults &AAR,
+                          const SCCNodeSet &SCCNodes,
+                          DenseMap<const Function *, ModRefInfo> *CSModRefMap);
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_FUNCTIONATTRSANALYSIS_H

include/llvm/Analysis/ModuleSummaryAnalysis.h

 #include <functional>
 
 namespace llvm {
 
 class BlockFrequencyInfo;
 class Function;
 class Module;
 class ProfileSummaryInfo;
+class AAResults;
 
 /// Direct function to compute a \c ModuleSummaryIndex from a given module.
 ///
 /// If operating within a pass manager which has defined ways to compute the \c
 /// BlockFrequencyInfo for a given function, that can be provided via
 /// a std::function callback. Otherwise, this routine will manually construct
 /// that information.
 ModuleSummaryIndex buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
-    ProfileSummaryInfo *PSI);
+    ProfileSummaryInfo *PSI,
+    std::function<AAResults *(const Function &F)> GetAARCallback = nullptr);
 
 /// Analysis pass to provide the ModuleSummaryIndex object.
 class ModuleSummaryIndexAnalysis
     : public AnalysisInfoMixin<ModuleSummaryIndexAnalysis> {
   friend AnalysisInfoMixin<ModuleSummaryIndexAnalysis>;
 
   static AnalysisKey Key;
 

include/llvm/IR/ModuleSummaryIndex.h

struct CalleeInfo {
   enum class HotnessType : uint8_t {
     Unknown = 0,
     Cold = 1,
     None = 2,
     Hot = 3,
     Critical = 4
   };
   HotnessType Hotness = HotnessType::Unknown;
+  enum class ModRefType : uint8_t { ReadNone = 0, ReadOnly = 1, MayWrite = 2 };
+  ModRefType ModRef = ModRefType::ReadNone;
 
   CalleeInfo() = default;
   explicit CalleeInfo(HotnessType Hotness) : Hotness(Hotness) {}
 
   void updateHotness(const HotnessType OtherHotness) {
     Hotness = std::max(Hotness, OtherHotness);
   }
+
+  void updateModRef(const ModRefType OtherModRef) {
+    ModRef = std::max(ModRef, OtherModRef);
+  }
 };
 
 class GlobalValueSummary;
 
 using GlobalValueSummaryList = std::vector<std::unique_ptr<GlobalValueSummary>>;
 
 struct GlobalValueSummaryInfo {
   /// The GlobalValue corresponding to this summary. This is only used in
public:
   struct ConstVCall {
     VFuncId VFunc;
     std::vector<uint64_t> Args;
   };
 
   /// Function attribute flags. Used to track if a function accesses memory,
   /// recurses or aliases.
   struct FFlags {
-    unsigned ReadNone : 1;
-    unsigned ReadOnly : 1;
+    unsigned ReadNone : 1; // TODO: change to ReadNoneIgnoringCalls
+    unsigned ReadOnly : 1; // TODO: change to ReadOnlyIgnoringCalls
     unsigned NoRecurse : 1;
     unsigned ReturnDoesNotAlias : 1;
   };
 
 private:
   /// Number of instructions (ignoring debug instructions, e.g.) computed
   /// during the initial compile step when the summary index is first built.
   unsigned InstCount;

include/llvm/Transforms/IPO/FunctionAttrs.h

 #define LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H
 
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-class AAResults;
-
-/// The three kinds of memory access relevant to 'readonly' and
-/// 'readnone' attributes.
-enum MemoryAccessKind {
-  MAK_ReadNone = 0,
-  MAK_ReadOnly = 1,
-  MAK_MayWrite = 2
-};
-
-/// Returns the memory access properties of this copy of the function.
-MemoryAccessKind computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR);
-
 /// Computes function attributes in post-order over the call graph.
 ///
 /// By operating in post-order, this pass computes precise attributes for
 /// called functions prior to processsing their callers. This "bottom-up"
 /// approach allows powerful interprocedural inference of function attributes
 /// like memory access patterns, etc. It can discover functions that do not
 /// access memory, or only read memory, and give them the readnone/readonly
 /// attribute. It also discovers function arguments that are not captured by

lib/Analysis/CMakeLists.txt

add_llvm_library(LLVMAnalysis
   ConstantFolding.cpp
   Delinearization.cpp
   DemandedBits.cpp
   DependenceAnalysis.cpp
   DivergenceAnalysis.cpp
   DomPrinter.cpp
   DominanceFrontier.cpp
   EHPersonalities.cpp
+  FunctionAttrsAnalysis.cpp
   GlobalsModRef.cpp
   IVUsers.cpp
   IndirectCallPromotionAnalysis.cpp
   InlineCost.cpp
   InstCount.cpp
   InstructionSimplify.cpp
   Interval.cpp
   IntervalPartition.cpp

lib/Analysis/FunctionAttrsAnalysis.cpp

+//===- FunctionAttrs.cpp - Pass which marks functions attributes ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements interprocedural passes which walk the
+/// call-graph deducing and/or propagating function attributes.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/FunctionAttrsAnalysis.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InstIterator.h"
+using namespace llvm;
+
+/// Returns the memory access attribute for function F using AAR for AA results,
+/// where SCCNodes is the current SCC.
+///
+/// If ThisBody is true, this function may examine the function body and will
+/// return a result pertaining to this copy of the function. If it is false, the
+/// result will be based only on AA results for the function declaration; it
+/// will be assumed that some other (perhaps less optimized) version of the
+/// function may be selected at link time.
+MemoryAccessKind llvm::checkFunctionMemoryAccess(
+    const Function &F, bool ThisBody, AAResults &AAR,
+    const SCCNodeSet &SCCNodes,
+    DenseMap<const Function *, ModRefInfo> *CSModRefMap) {
+  FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
+  if (MRB == FMRB_DoesNotAccessMemory)
+    // Already perfect!
+    return MAK_ReadNone;
+
+  if (!ThisBody) {
+    if (AliasAnalysis::onlyReadsMemory(MRB))
+      return MAK_ReadOnly;
+
+    // Conservatively assume it writes to memory.
+    return MAK_MayWrite;
+  }
+
+  // Scan the function body for instructions that may read or write memory.
+  bool ReadsMemory = false;
+  for (auto II = inst_begin(F), E = inst_end(F); II != E; ++II) {
+    const Instruction *I = &*II;
+
+    // Some instructions can be ignored even if they read or write memory.
+    // Detect these now, skipping to the next instruction if one is found.
+    ImmutableCallSite CS(cast<const Value>(I));
+    if (CS) {
+      // Ignore calls to functions in the same SCC, as long as the call sites
+      // don't have operand bundles.  Calls with operand bundles are allowed to
+      // have memory effects not described by the memory effects of the call
+      // target.
+      if (!CS.hasOperandBundles() && CS.getCalledFunction() &&
+          SCCNodes.count(const_cast<Function *>(CS.getCalledFunction())))
+        continue;
+
+      ModRefInfo *SaveModRef = nullptr;
+      if (!CS.hasOperandBundles() && CS.getCalledFunction() && CSModRefMap) {
+        auto Result =
+            CSModRefMap->try_emplace(CS.getCalledFunction(), MRI_NoModRef);
+        SaveModRef = &Result.first->second;
+      }
+
+      FunctionModRefBehavior MRB = AAR.getModRefBehavior(CS);
+
+      // If the call doesn't access memory, we're done.
+      if (!(MRB & MRI_ModRef))
+        continue;
+
+      if (!AliasAnalysis::onlyAccessesArgPointees(MRB)) {
+        // The call could access any memory. If that includes writes, give up.
+        if (MRB & MRI_Mod) {
+          if (SaveModRef)
+            (*SaveModRef) = MRI_Mod;
+          else
+            return MAK_MayWrite;
+        }
+        // If it reads, note it.
+        else if (MRB & MRI_Ref) {
+          if (SaveModRef && *SaveModRef == MRI_NoModRef)
+            (*SaveModRef) = MRI_Ref;
+          else
+            ReadsMemory = true;
+        }
+        continue;
+      }
+
+      // Check whether all pointer arguments point to local memory, and
+      // ignore calls that only access local memory.
+      for (auto CI = CS.arg_begin(), CE = CS.arg_end(); CI != CE; ++CI) {
+        Value *Arg = *CI;
+        if (!Arg->getType()->isPtrOrPtrVectorTy())
+          continue;
+
+        AAMDNodes AAInfo;
+        I->getAAMetadata(AAInfo);
+        MemoryLocation Loc(Arg, MemoryLocation::UnknownSize, AAInfo);
+
+        // Skip accesses to local or constant memory as they don't impact the
+        // externally visible mod/ref behavior.
+        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
+          continue;
+
+        if (MRB & MRI_Mod) {
+          if (SaveModRef)
+            (*SaveModRef) = MRI_Mod;
+          else
+            // Writes non-local memory.  Give up.
+            return MAK_MayWrite;
+        } else if (MRB & MRI_Ref) {
+          if (SaveModRef && *SaveModRef == MRI_NoModRef)
+            (*SaveModRef) = MRI_Ref;
+          else
+            // Ok, it reads non-local memory.
+            ReadsMemory = true;
+        }
+      }
+      continue;
+    } else if (const LoadInst *LI = dyn_cast<const LoadInst>(I)) {
+      // Ignore non-volatile loads from local memory. (Atomic is okay here.)
+      if (!LI->isVolatile()) {
+        MemoryLocation Loc = MemoryLocation::get(LI);
+        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
+          continue;
+      }
+    } else if (const StoreInst *SI = dyn_cast<const StoreInst>(I)) {
+      // Ignore non-volatile stores to local memory. (Atomic is okay here.)
+      if (!SI->isVolatile()) {
+        MemoryLocation Loc = MemoryLocation::get(SI);
+        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
+          continue;
+      }
+    } else if (const VAArgInst *VI = dyn_cast<const VAArgInst>(I)) {
+      // Ignore vaargs on local memory.
+      MemoryLocation Loc = MemoryLocation::get(VI);
+      if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
+        continue;
+    }
+
+    // Any remaining instructions need to be taken seriously!  Check if they
+    // read or write memory.
+    if (I->mayWriteToMemory())
+      // Writes memory.  Just give up.
+      return MAK_MayWrite;
+
+    // If this instruction may read memory, remember that.
+    ReadsMemory |= I->mayReadFromMemory();
+  }
+
+  return ReadsMemory ? MAK_ReadOnly : MAK_ReadNone;
+}
+
+MemoryAccessKind llvm::computeFunctionBodyMemoryAccess(
+    const Function &F, AAResults &AAR,
+    DenseMap<const Function *, ModRefInfo> *CSModRefMap) {
+  return checkFunctionMemoryAccess(F, /*ThisBody=*/true, AAR, {}, CSModRefMap);
+}

lib/Analysis/ModuleSummaryAnalysis.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
+#include "llvm/Analysis/FunctionAttrsAnalysis.h"
 #include "llvm/Analysis/IndirectCallPromotionAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
case Intrinsic::type_checked_load: {
 
     break;
   }
   default:
     break;
   }
 }
 
-static void
-computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
+static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
                                    const Function &F, BlockFrequencyInfo *BFI,
-                       ProfileSummaryInfo *PSI, bool HasLocalsInUsed,
-                       DenseSet<GlobalValue::GUID> &CantBePromoted) {
+                                   ProfileSummaryInfo *PSI,
+                                   bool HasLocalsInUsed,
+                                   DenseSet<GlobalValue::GUID> &CantBePromoted,
+                                   AAResults *AAR) {
   // Summary not currently supported for anonymous functions, they should
   // have been named.
   assert(F.hasName());
 
   unsigned NumInsts = 0;
   // Map from callee ValueId to profile count. Used to accumulate profile
   // counts for all static calls to a given callee.
   MapVector<ValueInfo, CalleeInfo> CallGraphEdges;
   SetVector<ValueInfo> RefEdges;
   SetVector<GlobalValue::GUID> TypeTests;
   SetVector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
       TypeCheckedLoadVCalls;
   SetVector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
       TypeCheckedLoadConstVCalls;
   ICallPromotionAnalysis ICallAnalysis;
 
+  DenseMap<const Function *, ModRefInfo> CSModRefMap;
+  bool ReadNone, ReadOnly;
+  if (AAR) {
+    auto MAK = computeFunctionBodyMemoryAccess(F, *AAR, &CSModRefMap);
+    ReadNone = MAK == MAK_ReadNone;
+    ReadOnly = MAK == MAK_ReadOnly;
+    errs() << "MemAccess for " << F.getName() << " is " << ReadNone << " "
+           << ReadOnly << "\n";
+  } else {
+    ReadNone = F.hasFnAttribute(Attribute::ReadNone);
+    ReadOnly = F.hasFnAttribute(Attribute::ReadOnly);
+  }
   bool HasInlineAsmMaybeReferencingInternal = false;
   SmallPtrSet<const User *, 8> Visited;
   for (const BasicBlock &BB : F)
     for (const Instruction &I : BB) {
       if (isa<DbgInfoIntrinsic>(I))
         continue;
       ++NumInsts;
       findRefEdges(Index, &I, RefEdges, Visited);
for (const Instruction &I : BB) {
 
         // Use the original CalledValue, in case it was an alias. We want
         // to record the call edge to the alias in that case. Eventually
         // an alias summary will be created to associate the alias and
         // aliasee.
         CallGraphEdges[Index.getOrInsertValueInfo(
                            cast<GlobalValue>(CalledValue))]
             .updateHotness(Hotness);
+        auto I = CSModRefMap.find(CalledFunction);
+        if (I != CSModRefMap.end()) {
+          ModRefInfo MRI = I->second;
+          CalleeInfo::ModRefType ModRef = CalleeInfo::ModRefType::ReadNone;
+          if (MRI & MRI_Mod)
+            ModRef = CalleeInfo::ModRefType::MayWrite;
+          else if (MRI & MRI_Ref)
+            ModRef = CalleeInfo::ModRefType::ReadOnly;
+          errs() << "ModRef for CalledFunction " << CalledFunction->getName()
+                 << " = " << (int)ModRef << "\n";
+          CallGraphEdges[Index.getOrInsertValueInfo(
+                             cast<GlobalValue>(CalledValue))]
+              .updateModRef(ModRef);
+        }
       } else {
         // Skip inline assembly calls.
         if (CI && CI->isInlineAsm())
           continue;
         // Skip direct calls.
         if (!CS.getCalledValue() || isa<Constant>(CS.getCalledValue()))
           continue;
 
static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
   bool NotEligibleForImport =
       NonRenamableLocal || HasInlineAsmMaybeReferencingInternal ||
       // Inliner doesn't handle variadic functions.
       // FIXME: refactor this to use the same code that inliner is using.
       F.isVarArg();
   GlobalValueSummary::GVFlags Flags(F.getLinkage(), NotEligibleForImport,
                                     /* Live = */ false);
   FunctionSummary::FFlags FunFlags{
-      F.hasFnAttribute(Attribute::ReadNone),
-      F.hasFnAttribute(Attribute::ReadOnly),
+      ReadNone,
+      ReadOnly,
       F.hasFnAttribute(Attribute::NoRecurse),
       F.returnDoesNotAlias(),
   };
   auto FuncSummary = llvm::make_unique<FunctionSummary>(
       Flags, NumInsts, FunFlags, RefEdges.takeVector(),
       CallGraphEdges.takeVector(), TypeTests.takeVector(),
       TypeTestAssumeVCalls.takeVector(), TypeCheckedLoadVCalls.takeVector(),
       TypeTestAssumeConstVCalls.takeVector(),
static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name) {
   if (ValueInfo VI = Index.getValueInfo(GlobalValue::getGUID(Name)))
     for (auto &Summary : VI.getSummaryList())
       Summary->setLive(true);
 }
 
 ModuleSummaryIndex llvm::buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
-    ProfileSummaryInfo *PSI) {
+    ProfileSummaryInfo *PSI,
+    std::function<AAResults *(const Function &F)> GetAARCallback) {
   assert(PSI);
   ModuleSummaryIndex Index;
 
   // Identify the local values in the llvm.used and llvm.compiler.used sets,
   // which should not be exported as they would then require renaming and
   // promotion, but we may have opaque uses e.g. in inline asm. We collect them
   // here because we use this information to mark functions containing inline
   // assembly calls as not importable.
for (auto &F : M) {
     if (GetBFICallback)
       BFI = GetBFICallback(F);
     else if (F.getEntryCount().hasValue()) {
       LoopInfo LI{DominatorTree(const_cast<Function &>(F))};
       BranchProbabilityInfo BPI{F, LI};
       BFIPtr = llvm::make_unique<BlockFrequencyInfo>(F, BPI, LI);
       BFI = BFIPtr.get();
     }
+    AAResults *AAR = GetAARCallback ? GetAARCallback(F) : nullptr;
 
     computeFunctionSummary(Index, M, F, BFI, PSI, !LocalsUsed.empty(),
-                           CantBePromoted);
+                           CantBePromoted, AAR);
   }
 
   // Compute summaries for all variables defined in module, and save in the
   // index.
   for (const GlobalVariable &G : M.globals()) {
     if (G.isDeclaration())
       continue;
     computeVariableSummary(Index, G, CantBePromoted);
ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
   ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
   return buildModuleSummaryIndex(
       M,
       [&FAM](const Function &F) {
         return &FAM.getResult<BlockFrequencyAnalysis>(
             *const_cast<Function *>(&F));
       },
-      &PSI);
+      &PSI,
+      [&FAM](const Function &F) {
+        return &FAM.getResult<AAManager>(*const_cast<Function *>(&F));
+      });
 }
 
 char ModuleSummaryIndexWrapperPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
                       "Module Summary Analysis", false, true)
 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
                     "Module Summary Analysis", false, true)
 
 ModulePass *llvm::createModuleSummaryIndexWrapperPass() {
   return new ModuleSummaryIndexWrapperPass();
 }
 
 ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass()
     : ModulePass(ID) {
   initializeModuleSummaryIndexWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) {
   auto &PSI = *getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
   Index = buildModuleSummaryIndex(
       M,
       [this](const Function &F) {
         return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
                          *const_cast<Function *>(&F))
                      .getBFI());
       },
-      &PSI);
+      &PSI,
+      [this](const Function &F) {
+        return &(
+            this->getAnalysis<AAResultsWrapperPass>(*const_cast<Function *>(&F))
+                .getAAResults());
+      });
   return false;
 }
 
 bool ModuleSummaryIndexWrapperPass::doFinalization(Module &M) {
   Index.reset();
   return false;
 }
 
 void ModuleSummaryIndexWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<BlockFrequencyInfoWrapperPass>();
   AU.addRequired<ProfileSummaryInfoWrapperPass>();
+  AU.addRequired<AAResultsWrapperPass>();
 }

lib/Transforms/IPO/FunctionAttrs.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/CaptureTracking.h"
+#include "llvm/Analysis/FunctionAttrsAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"

 // FIXME: This is disabled by default to avoid exposing security vulnerabilities
 // in C/C++ code compiled by clang:
 // http://lists.llvm.org/pipermail/cfe-dev/2017-January/052066.html
 static cl::opt<bool> EnableNonnullArgPropagation(
     "enable-nonnull-arg-prop", cl::Hidden,
     cl::desc("Try to propagate nonnull argument attributes from callsites to "
              "caller functions."));
 
-namespace {
-typedef SmallSetVector<Function *, 8> SCCNodeSet;
-}
-
-/// Returns the memory access attribute for function F using AAR for AA results,
-/// where SCCNodes is the current SCC.
-///
-/// If ThisBody is true, this function may examine the function body and will
-/// return a result pertaining to this copy of the function. If it is false, the
-/// result will be based only on AA results for the function declaration; it
-/// will be assumed that some other (perhaps less optimized) version of the
-/// function may be selected at link time.
-static MemoryAccessKind checkFunctionMemoryAccess(Function &F, bool ThisBody,
-                                                  AAResults &AAR,
-                                                  const SCCNodeSet &SCCNodes) {
-  FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
-  if (MRB == FMRB_DoesNotAccessMemory)
-    // Already perfect!
-    return MAK_ReadNone;
-
-  if (!ThisBody) {
-    if (AliasAnalysis::onlyReadsMemory(MRB))
-      return MAK_ReadOnly;
-
-    // Conservatively assume it writes to memory.
-    return MAK_MayWrite;
-  }
-
-  // Scan the function body for instructions that may read or write memory.
-  bool ReadsMemory = false;
-  for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
-    Instruction *I = &*II;
-
-    // Some instructions can be ignored even if they read or write memory.
-    // Detect these now, skipping to the next instruction if one is found.
-    CallSite CS(cast<Value>(I));
-    if (CS) {
-      // Ignore calls to functions in the same SCC, as long as the call sites
-      // don't have operand bundles.  Calls with operand bundles are allowed to
-      // have memory effects not described by the memory effects of the call
-      // target.
-      if (!CS.hasOperandBundles() && CS.getCalledFunction() &&
-          SCCNodes.count(CS.getCalledFunction()))
-        continue;
-      FunctionModRefBehavior MRB = AAR.getModRefBehavior(CS);
-
-      // If the call doesn't access memory, we're done.
-      if (!(MRB & MRI_ModRef))
-        continue;
-
-      if (!AliasAnalysis::onlyAccessesArgPointees(MRB)) {
-        // The call could access any memory. If that includes writes, give up.
-        if (MRB & MRI_Mod)
-          return MAK_MayWrite;
-        // If it reads, note it.
-        if (MRB & MRI_Ref)
-          ReadsMemory = true;
-        continue;
-      }
-
-      // Check whether all pointer arguments point to local memory, and
-      // ignore calls that only access local memory.
-      for (CallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
-           CI != CE; ++CI) {
-        Value *Arg = *CI;
-        if (!Arg->getType()->isPtrOrPtrVectorTy())
-          continue;
-
-        AAMDNodes AAInfo;
-        I->getAAMetadata(AAInfo);
-        MemoryLocation Loc(Arg, MemoryLocation::UnknownSize, AAInfo);
-
-        // Skip accesses to local or constant memory as they don't impact the
-        // externally visible mod/ref behavior.
-        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
-          continue;
-
-        if (MRB & MRI_Mod)
-          // Writes non-local memory.  Give up.
-          return MAK_MayWrite;
-        if (MRB & MRI_Ref)
-          // Ok, it reads non-local memory.
-          ReadsMemory = true;
-      }
-      continue;
-    } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
-      // Ignore non-volatile loads from local memory. (Atomic is okay here.)
-      if (!LI->isVolatile()) {
-        MemoryLocation Loc = MemoryLocation::get(LI);
-        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
-          continue;
-      }
-    } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
-      // Ignore non-volatile stores to local memory. (Atomic is okay here.)
-      if (!SI->isVolatile()) {
-        MemoryLocation Loc = MemoryLocation::get(SI);
-        if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
-          continue;
-      }
-    } else if (VAArgInst *VI = dyn_cast<VAArgInst>(I)) {
-      // Ignore vaargs on local memory.
-      MemoryLocation Loc = MemoryLocation::get(VI);
-      if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
-        continue;
-    }
-
-    // Any remaining instructions need to be taken seriously!  Check if they
-    // read or write memory.
-    if (I->mayWriteToMemory())
-      // Writes memory.  Just give up.
-      return MAK_MayWrite;
-
-    // If this instruction may read memory, remember that.
-    ReadsMemory |= I->mayReadFromMemory();
-  }
-
-  return ReadsMemory ? MAK_ReadOnly : MAK_ReadNone;
-}
-
-MemoryAccessKind llvm::computeFunctionBodyMemoryAccess(Function &F,
-                                                       AAResults &AAR) {
-  return checkFunctionMemoryAccess(F, /*ThisBody=*/true, AAR, {});
-}
-
 /// Deduce readonly/readnone attributes for the SCC.
 template <typename AARGetterT>
 static bool addReadAttrs(const SCCNodeSet &SCCNodes, AARGetterT &&AARGetter) {
   // Check if any of the functions in the SCC read or write memory.  If they
   // write memory then they can't be marked readnone or readonly.
   bool ReadsMemory = false;
   for (Function *F : SCCNodes) {
     // Call the callable parameter to look up AA results for this function.
     AAResults &AAR = AARGetter(*F);
 
     // Non-exact function definitions may not be selected at link time, and an
     // alternative version that writes to memory may be selected.  See the
     // comment on GlobalValue::isDefinitionExact for more details.
-    switch (checkFunctionMemoryAccess(*F, F->hasExactDefinition(),
-                                      AAR, SCCNodes)) {
+    switch (checkFunctionMemoryAccess(*F, F->hasExactDefinition(), AAR,
+                                      SCCNodes, nullptr)) {
     case MAK_MayWrite:
       return false;
     case MAK_ReadOnly:
       ReadsMemory = true;
       break;
     case MAK_ReadNone:
       // Nothing to do!
       break;

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

 //===- ThinLTOBitcodeWriter.cpp - Bitcode writing pass for ThinLTO --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/Analysis/FunctionAttrsAnalysis.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 using namespace llvm;
 
 namespace {
 
 // Promote each local-linkage entity defined by ExportM and used by ImportM by
 // changing visibility and appending the given ModuleId.

lib/Transforms/IPO/WholeProgramDevirt.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/Analysis/FunctionAttrsAnalysis.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"

 #include "llvm/Pass.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/PassSupport.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/Utils/Evaluator.h"
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <set>
 #include <string>
 
 using namespace llvm;