[ArgPromotion] Remove all the getters and ReplaceCallSite

[psamolysov]

Summary

AARGetter is an abstraction over a source of the AAResults introduced
to support the legacy pass manager as well as the modern one. Since the
Argument Promotion pass doesn't support the legacy pass manager anymore,
the abstraction is not required and AAResults may be used directly.

The instance of the FunctionAnalysisManager is passed through the
functions to get all the required analyses just wherever they are
required and do not use the awkward getter callbacks.

The ReplaceCallSite parameter was required for the legacy pass manager
only and isn't used anymore, so the parameter has been eliminated.

[nikic]

The disadvantage is that AAResult gets computed unconditionally, while previously it was only computed if the function was a viable promotion candidate.

Maybe we want to pass through FunctionAnalysisManager to avoid the awkward callbacks, while keeping the current positions of the lookup?

[psamolysov]

Good catch, thank you. I think the ReplicaCallSite parameter can be removed too because we pass only None for it.

[psamolysov]

Eliminate all the getters as well as the ReplaceCallSite parameter.

[psamolysov]

Remove #include of unused headers.

[aeubanks]

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

44

some of these includes should still be here, like CGSCCPassManager, LazyCallGraph, and Module

[psamolysov]

CGSCCPassManager and LazyCallGraph are included in the class' header. About Module I'm not sure, CLion marks this header as unused, I also see no Module in the code.

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
static bool areTypesABICompatible(ArrayRef<Type *> Types, const Function &F,
   });
 }
 
 /// PromoteArguments - This method checks the specified function to see if there
 /// are any promotable arguments and if it is safe to promote the function (for
 /// example, all callers are direct).  If safe to promote some arguments, it
 /// calls the DoPromotion method.
 static Function *
-promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
+promoteArguments(Function *F, AAResults &AAR,
                  function_ref<DominatorTree &(Function &F)> DTGetter,
                  function_ref<AssumptionCache *(Function &F)> ACGetter,
                  unsigned MaxElements,
                  Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
                      ReplaceCallSite,
                  const TargetTransformInfo &TTI, bool IsRecursive) {
   // Don't perform argument promotion for naked functions; otherwise we can end
   // up removing parameters that are seemingly 'not used' as they are referred
promoteArguments(Function *F, AAResults &AAR,
   // Can't change signature of musttail caller
   // FIXME: Support promoting whole chain of musttail functions
   for (BasicBlock &BB : *F)
     if (BB.getTerminatingMustTailCall())
       return nullptr;
 
   const DataLayout &DL = F->getParent()->getDataLayout();
 
-  AAResults &AAR = AARGetter(*F);
-
   // Check to see which arguments are promotable.  If an argument is promotable,
   // add it to ArgsToPromote.
   DenseMap<Argument *, SmallVector<OffsetAndArgPart, 4>> ArgsToPromote;
   for (Argument *PtrArg : PointerArgs) {
     // Replace sret attribute with noalias. This reduces register pressure by
     // avoiding a register copy.
     if (PtrArg->hasStructRetAttr()) {
       unsigned ArgNo = PtrArg->getArgNo();
do {
 
     FunctionAnalysisManager &FAM =
         AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
 
     bool IsRecursive = C.size() > 1;
     for (LazyCallGraph::Node &N : C) {
       Function &OldF = N.getFunction();
 
-      // FIXME: This lambda must only be used with this function. We should
-      // skip the lambda and just get the AA results directly.
-      auto AARGetter = [&](Function &F) -> AAResults & {
-        assert(&F == &OldF && "Called with an unexpected function!");
-        return FAM.getResult<AAManager>(F);
-      };
-
       auto DTGetter = [&](Function &F) -> DominatorTree & {
         assert(&F != &OldF && "Called with the obsolete function!");
         return FAM.getResult<DominatorTreeAnalysis>(F);
       };
 
       auto ACGetter = [&](Function &F) -> AssumptionCache * {
         assert(&F != &OldF && "Called with the obsolete function!");
         return &FAM.getResult<AssumptionAnalysis>(F);
       };
 
+      auto &AAR = FAM.getResult<AAManager>(OldF);
       const auto &TTI = FAM.getResult<TargetIRAnalysis>(OldF);
-      Function *NewF = promoteArguments(&OldF, AARGetter, DTGetter, ACGetter,
+      Function *NewF = promoteArguments(&OldF, AAR, DTGetter, ACGetter,
                                         MaxElements, None, TTI, IsRecursive);
       if (!NewF)
         continue;
       LocalChange = true;
 
       // Directly substitute the functions in the call graph. Note that this
       // requires the old function to be completely dead and completely
       // replaced by the new function. It does no call graph updates, it merely