LLVM 19.0.0git
CallGraphUpdater.h
Go to the documentation of this file.
1//===- CallGraphUpdater.h - A (lazy) call graph update helper ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file provides interfaces used to manipulate a call graph, regardless
11/// if it is a "old style" CallGraph or an "new style" LazyCallGraph.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
16#define LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
17
20
21namespace llvm {
22
23class CallGraph;
24class CallGraphSCC;
25
26/// Wrapper to unify "old style" CallGraph and "new style" LazyCallGraph. This
27/// simplifies the interface and the call sites, e.g., new and old pass manager
28/// passes can share the same code.
30 /// Containers for functions which we did replace or want to delete when
31 /// `finalize` is called. This can happen explicitly or as part of the
32 /// destructor. Dead functions in comdat sections are tracked separately
33 /// because a function with discardable linakage in a COMDAT should only
34 /// be dropped if the entire COMDAT is dropped, see git ac07703842cf.
35 ///{
36 SmallPtrSet<Function *, 16> ReplacedFunctions;
37 SmallVector<Function *, 16> DeadFunctions;
38 SmallVector<Function *, 16> DeadFunctionsInComdats;
39 ///}
40
41 /// New PM variables
42 ///{
43 LazyCallGraph *LCG = nullptr;
44 LazyCallGraph::SCC *SCC = nullptr;
45 CGSCCAnalysisManager *AM = nullptr;
46 CGSCCUpdateResult *UR = nullptr;
47 FunctionAnalysisManager *FAM = nullptr;
48 ///}
49
50public:
51 CallGraphUpdater() = default;
53
54 /// Initializers for usage outside of a CGSCC pass, inside a CGSCC pass in
55 /// the old and new pass manager (PM).
56 ///{
59 this->LCG = &LCG;
60 this->SCC = &SCC;
61 this->AM = &AM;
62 this->UR = &UR;
63 FAM =
64 &AM.getResult<FunctionAnalysisManagerCGSCCProxy>(SCC, LCG).getManager();
65 }
66 ///}
67
68 /// Finalizer that will trigger actions like function removal from the CG.
69 bool finalize();
70
71 /// Remove \p Fn from the call graph.
72 void removeFunction(Function &Fn);
73
74 /// After an CGSCC pass changes a function in ways that affect the call
75 /// graph, this method can be called to update it.
77
78 /// If a new function was created by outlining, this method can be called
79 /// to update the call graph for the new function. Note that the old one
80 /// still needs to be re-analyzed or manually updated.
81 void registerOutlinedFunction(Function &OriginalFn, Function &NewFn);
82
83 /// Replace \p OldFn in the call graph (and SCC) with \p NewFn. The uses
84 /// outside the call graph and the function \p OldFn are not modified.
85 /// Note that \p OldFn is also removed from the call graph
86 /// (\see removeFunction).
87 void replaceFunctionWith(Function &OldFn, Function &NewFn);
88};
89
90} // end namespace llvm
91
92#endif // LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
This header provides classes for managing passes over SCCs of the call graph.
Implements a lazy call graph analysis and related passes for the new pass manager.
FunctionAnalysisManager FAM
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:405
Wrapper to unify "old style" CallGraph and "new style" LazyCallGraph.
void registerOutlinedFunction(Function &OriginalFn, Function &NewFn)
If a new function was created by outlining, this method can be called to update the call graph for th...
void removeFunction(Function &Fn)
Remove Fn from the call graph.
void replaceFunctionWith(Function &OldFn, Function &NewFn)
Replace OldFn in the call graph (and SCC) with NewFn.
void reanalyzeFunction(Function &Fn)
After an CGSCC pass changes a function in ways that affect the call graph, this method can be called ...
void initialize(LazyCallGraph &LCG, LazyCallGraph::SCC &SCC, CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR)
Initializers for usage outside of a CGSCC pass, inside a CGSCC pass in the old and new pass manager (...
CallGraphUpdater()=default
}
A proxy from a FunctionAnalysisManager to an SCC.
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:479
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...