[llvm] 3d9ce9e - [ArgPromotion] Remove all the getters and ReplaceCallSite (NFC)
Pavel Samolysov via llvm-commits
llvm-commits at lists.llvm.org
Wed Jun 29 00:48:25 PDT 2022
Author: Pavel Samolysov
Date: 2022-06-29T10:45:11+03:00
New Revision: 3d9ce9e43d07bbd3ab5c25ee36f417e3d372b94b
URL: https://github.com/llvm/llvm-project/commit/3d9ce9e43d07bbd3ab5c25ee36f417e3d372b94b
DIFF: https://github.com/llvm/llvm-project/commit/3d9ce9e43d07bbd3ab5c25ee36f417e3d372b94b.diff
LOG: [ArgPromotion] Remove all the getters and ReplaceCallSite (NFC)
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.
Differential Revision: https://reviews.llvm.org/D128727
Added:
Modified:
llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
index 1455344f0a823..62cfc32949681 100644
--- a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -31,8 +31,6 @@
#include "llvm/Transforms/IPO/ArgumentPromotion.h"
#include "llvm/ADT/DepthFirstIterator.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SmallPtrSet.h"
@@ -41,13 +39,9 @@
#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"
#include "llvm/IR/Argument.h"
@@ -64,19 +58,15 @@
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Metadata.h"
-#include "llvm/IR/Module.h"
#include "llvm/IR/NoFolder.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Use.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
#include <algorithm>
#include <cassert>
@@ -155,12 +145,10 @@ static Value *createByteGEP(IRBuilderBase &IRB, const DataLayout &DL,
/// DoPromotion - This method actually performs the promotion of the specified
/// arguments, and returns the new function. At this point, we know that it's
/// safe to do so.
-static Function *doPromotion(
- Function *F, function_ref<DominatorTree &(Function &F)> DTGetter,
- function_ref<AssumptionCache *(Function &F)> ACGetter,
- const DenseMap<Argument *, SmallVector<OffsetAndArgPart, 4>> &ArgsToPromote,
- Optional<function_ref<void(CallBase &OldCS, CallBase &NewCS)>>
- ReplaceCallSite) {
+static Function *
+doPromotion(Function *F, FunctionAnalysisManager &FAM,
+ const DenseMap<Argument *, SmallVector<OffsetAndArgPart, 4>>
+ &ArgsToPromote) {
// Start by computing a new prototype for the function, which is the same as
// the old function, but has modified arguments.
FunctionType *FTy = F->getFunctionType();
@@ -228,9 +216,8 @@ static Function *doPromotion(
F->getParent()->getFunctionList().insert(F->getIterator(), NF);
NF->takeName(F);
- // Loop over all of the callers of the function, transforming the call sites
- // to pass in the loaded pointers.
- //
+ // Loop over all the callers of the function, transforming the call sites to
+ // pass in the loaded pointers.
SmallVector<Value *, 16> Args;
const DataLayout &DL = F->getParent()->getDataLayout();
while (!F->use_empty()) {
@@ -299,10 +286,6 @@ static Function *doPromotion(
AttributeFuncs::updateMinLegalVectorWidthAttr(*CB.getCaller(),
LargestVectorWidth);
- // Update the callgraph to know that the callsite has been transformed.
- if (ReplaceCallSite)
- (*ReplaceCallSite)(CB, *NewCS);
-
if (!CB.use_empty()) {
CB.replaceAllUsesWith(NewCS);
NewCS->takeName(&CB);
@@ -429,7 +412,9 @@ static Function *doPromotion(
// And we are able to call the `promoteMemoryToRegister()` function.
// Our earlier checks have ensured that PromoteMemToReg() will
// succeed.
- PromoteMemToReg(Allocas, DTGetter(*NF), ACGetter(*NF));
+ auto &DT = FAM.getResult<DominatorTreeAnalysis>(*NF);
+ auto &AC = FAM.getResult<AssumptionAnalysis>(*NF);
+ PromoteMemToReg(Allocas, DT, &AC);
}
return NF;
@@ -717,14 +702,8 @@ static bool areTypesABICompatible(ArrayRef<Type *> Types, const Function &F,
/// 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,
- 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) {
+static Function *promoteArguments(Function *F, FunctionAnalysisManager &FAM,
+ unsigned MaxElements, 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
// to in the assembly.
@@ -781,8 +760,8 @@ promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
return nullptr;
const DataLayout &DL = F->getParent()->getDataLayout();
-
- AAResults &AAR = AARGetter(*F);
+ auto &AAR = FAM.getResult<AAManager>(*F);
+ const auto &TTI = FAM.getResult<TargetIRAnalysis>(*F);
// Check to see which arguments are promotable. If an argument is promotable,
// add it to ArgsToPromote.
@@ -819,7 +798,7 @@ promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
if (ArgsToPromote.empty())
return nullptr;
- return doPromotion(F, DTGetter, ACGetter, ArgsToPromote, ReplaceCallSite);
+ return doPromotion(F, FAM, ArgsToPromote);
}
PreservedAnalyses ArgumentPromotionPass::run(LazyCallGraph::SCC &C,
@@ -838,27 +817,7 @@ PreservedAnalyses ArgumentPromotionPass::run(LazyCallGraph::SCC &C,
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);
- };
-
- const auto &TTI = FAM.getResult<TargetIRAnalysis>(OldF);
- Function *NewF = promoteArguments(&OldF, AARGetter, DTGetter, ACGetter,
- MaxElements, None, TTI, IsRecursive);
+ Function *NewF = promoteArguments(&OldF, FAM, MaxElements, IsRecursive);
if (!NewF)
continue;
LocalChange = true;
More information about the llvm-commits
mailing list