[Attributor] Create helper struct for handling analysis getters

[uenoku]

Summary

This patch introduces a helper struct AnalysisGetter to put together analysis getters. In this patch, a getter for AAResult is also added for noalias.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

4113

Can we move this stuff into the AnalysisGetter as well? e.g., only pass the FAM or even the module manager AM?

[uenoku]

Pass FAM to AnalysisGetter.

[jdoerfert]

I like this version a lot better, thx. LGTM.

llvm/include/llvm/Transforms/IPO/Attributor.h

 //   need to traverse the IR repeatedly.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 #define LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 
 #include "llvm/ADT/SetVector.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct AbstractAttribute;
class SubsumingPositionIterator {
   using iterator = decltype(IRPositions)::iterator;
 
 public:
   SubsumingPositionIterator(const IRPosition &IRP);
   iterator begin() { return IRPositions.begin(); }
   iterator end() { return IRPositions.end(); }
 };
 
+/// Helper class for handling analysis getters.
+struct AnalysisGetter {
+
+  /// A map type from functions to their TLI.
+  using FuncTLIMapTy = std::function<TargetLibraryInfo *(const Function *)>;
+  FuncTLIMapTy FuncTLIMap;
+
+  /// A map type from functions to their Alias Analysis.
+  using FuncAARMapTy = std::function<AAResults *(const Function *)>;
+  FuncAARMapTy FuncAARMap;
+
+  AnalysisGetter(FuncTLIMapTy &FuncTLIMap, FuncAARMapTy &FuncAARMap)
+      : FuncTLIMap(FuncTLIMap), FuncAARMap(FuncAARMap) {}
+
+  AnalysisGetter()
+      : FuncTLIMap(getDummyGetter<TargetLibraryInfo>()),
+        FuncAARMap(getDummyGetter<AAResults>()) {}
+
+  // Helper function for creating a function which returns nullptr.
+  template <typename T> static std::function<T *(const Function *)> getDummyGetter() {
+    std::function<T *(const Function *)> Dummy = [](const Function *) -> T * {
+      return nullptr;
+    };
+    return Dummy;
+  }
+};
+
 /// Data structure to hold cached (LLVM-IR) information.
 ///
 /// All attributes are given an InformationCache object at creation time to
 /// avoid inspection of the IR by all of them individually. This default
 /// InformationCache will hold information required by 'default' attributes,
 /// thus the ones deduced when Attributor::identifyDefaultAbstractAttributes(..)
 /// is called.
 ///
 /// If custom abstract attributes, registered manually through
 /// Attributor::registerAA(...), need more information, especially if it is not
 /// reusable, it is advised to inherit from the InformationCache and cast the
 /// instance down in the abstract attributes.
 struct InformationCache {
-  InformationCache(const DataLayout &DL) : DL(DL) {}
+  InformationCache(const DataLayout &DL, const AnalysisGetter &AG)
+      : DL(DL), AG(AG) {}
 
   /// A map type from opcodes to instructions with this opcode.
   using OpcodeInstMapTy = DenseMap<unsigned, SmallVector<Instruction *, 32>>;
 
   /// Return the map that relates "interesting" opcodes with all instructions
   /// with that opcode in \p F.
   OpcodeInstMapTy &getOpcodeInstMapForFunction(const Function &F) {
     return FuncInstOpcodeMap[&F];
   }
 
   /// A vector type to hold instructions.
   using InstructionVectorTy = std::vector<Instruction *>;
 
   /// Return the instructions in \p F that may read or write memory.
   InstructionVectorTy &getReadOrWriteInstsForFunction(const Function &F) {
     return FuncRWInstsMap[&F];
   }
 
   /// Return TargetLibraryInfo for function \p F.
   TargetLibraryInfo *getTargetLibraryInfoForFunction(const Function &F) {
-    return FuncTLIMap[&F];
+    return AG.FuncTLIMap(&F);
+  }
+
+  /// Return AliasAnalysis Result for function \p F.
+  AAResults *getAAResultsForFunction(const Function &F) {
+    return AG.FuncAARMap(&F);
   }
 
   /// Return datalayout used in the module.
   const DataLayout &getDL() { return DL; }
 
 private:
   /// A map type from functions to opcode to instruction maps.
   using FuncInstOpcodeMapTy = DenseMap<const Function *, OpcodeInstMapTy>;
 
   /// A map type from functions to their read or write instructions.
   using FuncRWInstsMapTy = DenseMap<const Function *, InstructionVectorTy>;
 
-  /// A map type from functions to their TLI.
-  using FuncTLIMapTy = DenseMap<const Function *, TargetLibraryInfo *>;
-
   /// A nested map that remembers all instructions in a function with a certain
   /// instruction opcode (Instruction::getOpcode()).
   FuncInstOpcodeMapTy FuncInstOpcodeMap;
 
   /// A map from functions to their instructions that may read or write memory.
   FuncRWInstsMapTy FuncRWInstsMap;
 
   /// A map from functions to their TLI.
-  FuncTLIMapTy FuncTLIMap;
 
   /// The datalayout used in the module.
   const DataLayout &DL;
 
+  /// Getters for analysis.
+  const AnalysisGetter &AG;
+
   /// Give the Attributor access to the members so
   /// Attributor::identifyDefaultAbstractAttributes(...) can initialize them.
   friend struct Attributor;
 };
 
 /// The fixpoint analysis framework that orchestrates the attribute deduction.
 ///
 /// The Attributor provides a general abstract analysis framework (guided
struct Attributor {
   /// \param F The function that is checked for attribute opportunities.
   /// \param TLIGetter helper function to get TargetLibraryInfo Analysis result.
   ///
   /// Note that abstract attribute instances are generally created even if the
   /// IR already contains the information they would deduce. The most important
   /// reason for this is the single interface, the one of the abstract attribute
   /// instance, which can be queried without the need to look at the IR in
   /// various places.
-  void identifyDefaultAbstractAttributes(
-      Function &F, std::function<TargetLibraryInfo *(Function &)> &TLIGetter);
+  void identifyDefaultAbstractAttributes(Function &F);
 
   /// Mark the internal function \p F as live.
   ///
   /// This will trigger the identification and initialization of attributes for
   /// \p F.
   void markLiveInternalFunction(const Function &F) {
     assert(F.hasInternalLinkage() &&
-            "Only internal linkage is assumed dead initially.");
 
-    std::function<TargetLibraryInfo *(Function &)> TLIGetter =
-        [&](Function &F) -> TargetLibraryInfo * { return nullptr; };
-
-    identifyDefaultAbstractAttributes(const_cast<Function &>(F), TLIGetter);
+    identifyDefaultAbstractAttributes(const_cast<Function &>(F));
   }
 
   /// Record that \p I is deleted after information was manifested.
   void deleteAfterManifest(Instruction &I) { ToBeDeletedInsts.insert(&I); }
 
   /// Record that \p BB is deleted after information was manifested.
   void deleteAfterManifest(BasicBlock &BB) { ToBeDeletedBlocks.insert(&BB); }
 

llvm/lib/Transforms/IPO/Attributor.cpp

errs() << "\n[Attributor] Fixpoint iteration done after: "
            << " iterations\n";
     llvm_unreachable("The fixpoint was not reached with exactly the number of "
                      "specified iterations!");
   }
 
   return ManifestChange;
 }
 
-void Attributor::identifyDefaultAbstractAttributes(
-    Function &F, std::function<TargetLibraryInfo *(Function &)> &TLIGetter) {
+void Attributor::identifyDefaultAbstractAttributes(Function &F) {
   if (!VisitedFunctions.insert(&F).second)
     return;
 
-  if (EnableHeapToStack)
-    InfoCache.FuncTLIMap[&F] = TLIGetter(F);
-
   IRPosition FPos = IRPosition::function(F);
 
   // Check for dead BasicBlocks in every function.
   // We need dead instruction detection because we do not want to deal with
   // broken IR in which SSA rules do not apply.
   getOrCreateAAFor<AAIsDead>(FPos);
 
   // Every function might be "will-return".
OS << "[P: " << getIRPosition() << "][" << getAsStr() << "][S: " << getState()
      << "]";
 }
 ///}
 
 /// ----------------------------------------------------------------------------
 ///                       Pass (Manager) Boilerplate
 /// ----------------------------------------------------------------------------
 
-static bool runAttributorOnModule(
-    Module &M, std::function<TargetLibraryInfo *(Function &)> &TLIGetter) {
+static bool runAttributorOnModule(Module &M, AnalysisGetter &AG) {
   if (DisableAttributor)
     return false;
 
   LLVM_DEBUG(dbgs() << "[Attributor] Run on module with " << M.size()
                     << " functions.\n");
 
   // Create an Attributor and initially empty information cache that is filled
   // while we identify default attribute opportunities.
-  InformationCache InfoCache(M.getDataLayout());
+  InformationCache InfoCache(M.getDataLayout(), AG);
   Attributor A(InfoCache, DepRecInterval);
 
   for (Function &F : M) {
     if (F.hasExactDefinition())
       NumFnWithExactDefinition++;
     else
       NumFnWithoutExactDefinition++;
 
if (F.hasInternalLinkage()) {
             return ImmutableCallSite(U.getUser()) &&
                    ImmutableCallSite(U.getUser()).isCallee(&U);
           }))
         continue;
     }
 
     // Populate the Attributor with abstract attribute opportunities in the
     // function and the information cache with IR information.
-    A.identifyDefaultAbstractAttributes(F, TLIGetter);
+    A.identifyDefaultAbstractAttributes(F);
   }
 
   return A.run(M) == ChangeStatus::CHANGED;
 }
 
 PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
 
-  std::function<TargetLibraryInfo *(Function &)> TLIGetter =
-      [&](Function &F) -> TargetLibraryInfo * {
-    return &FAM.getResult<TargetLibraryAnalysis>(F);
+  AnalysisGetter::FuncTLIMapTy TLIGetter =
+      [&](const Function *F) -> TargetLibraryInfo * {
+    return &FAM.getResult<TargetLibraryAnalysis>(const_cast<Function &>(*F));
+  };
+  AnalysisGetter::FuncAARMapTy AARGetter =
+      [&](const Function *F) -> AAResults * {
+    return &FAM.getResult<AAManager>(const_cast<Function &>(*F));
   };
 
-  if (runAttributorOnModule(M, TLIGetter)) {
+  AnalysisGetter AG(TLIGetter, AARGetter);
+  if (runAttributorOnModule(M, AG)) {
     // FIXME: Think about passes we will preserve and add them here.
     return PreservedAnalyses::none();
   }
   return PreservedAnalyses::all();
 }
 
 namespace {
 
 struct AttributorLegacyPass : public ModulePass {
   static char ID;
 
   AttributorLegacyPass() : ModulePass(ID) {
     initializeAttributorLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnModule(Module &M) override {
     if (skipModule(M))
       return false;
-    std::function<TargetLibraryInfo *(Function &)> TLIGetter =
-        [&](Function &F) -> TargetLibraryInfo * { return nullptr; };
 
-    return runAttributorOnModule(M, TLIGetter);
+    AnalysisGetter AG;
+    return runAttributorOnModule(M, AG);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: Think about passes we will preserve and add them here.
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 };