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
18#include "llvm/Analysis/CGSCCPassManager.h"
19#include "llvm/Analysis/CallGraph.h"
20#include "llvm/Analysis/CallGraphSCCPass.h"
21#include "llvm/Analysis/LazyCallGraph.h"
22
23namespace llvm {
24
25/// Wrapper to unify "old style" CallGraph and "new style" LazyCallGraph. This
26/// simplifies the interface and the call sites, e.g., new and old pass manager
27/// passes can share the same code.
28class CallGraphUpdater {
29 /// Containers for functions which we did replace or want to delete when
30 /// `finalize` is called. This can happen explicitly or as part of the
31 /// destructor. Dead functions in comdat sections are tracked separately
32 /// because a function with discardable linakage in a COMDAT should only
33 /// be dropped if the entire COMDAT is dropped, see git ac07703842cf.
34 ///{
35 SmallPtrSet<Function *, 16> ReplacedFunctions;
36 SmallVector<Function *, 16> DeadFunctions;
37 SmallVector<Function *, 16> DeadFunctionsInComdats;
38 ///}
39
40 /// Old PM variables
41 ///{
42 CallGraph *CG = nullptr;
43 CallGraphSCC *CGSCC = nullptr;
44 ///}
45
46 /// New PM variables
47 ///{
48 LazyCallGraph *LCG = nullptr;
49 LazyCallGraph::SCC *SCC = nullptr;
50 CGSCCAnalysisManager *AM = nullptr;
51 CGSCCUpdateResult *UR = nullptr;
52 FunctionAnalysisManager *FAM = nullptr;
53 ///}
54
55public:
56 CallGraphUpdater() {}
57 ~CallGraphUpdater() { finalize(); }
58
59 /// Initializers for usage outside of a CGSCC pass, inside a CGSCC pass in
60 /// the old and new pass manager (PM).
61 ///{
62 void initialize(CallGraph &CG, CallGraphSCC &SCC) {
63 this->CG = &CG;
64 this->CGSCC = &SCC;
65 }
66 void initialize(LazyCallGraph &LCG, LazyCallGraph::SCC &SCC,
67 CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR) {
68 this->LCG = &LCG;
69 this->SCC = &SCC;
70 this->AM = &AM;
71 this->UR = &UR;
72 FAM =
73 &AM.getResult<FunctionAnalysisManagerCGSCCProxy>(SCC, LCG).getManager();
74 }
75 ///}
76
77 /// Finalizer that will trigger actions like function removal from the CG.
78 bool finalize();
79
80 /// Remove \p Fn from the call graph.
81 void removeFunction(Function &Fn);
82
83 /// After an CGSCC pass changes a function in ways that affect the call
84 /// graph, this method can be called to update it.
85 void reanalyzeFunction(Function &Fn);
86
87 /// If a new function was created by outlining, this method can be called
88 /// to update the call graph for the new function. Note that the old one
89 /// still needs to be re-analyzed or manually updated.
90 void registerOutlinedFunction(Function &OriginalFn, Function &NewFn);
91
92 /// Replace \p OldFn in the call graph (and SCC) with \p NewFn. The uses
93 /// outside the call graph and the function \p OldFn are not modified.
94 /// Note that \p OldFn is also removed from the call graph
95 /// (\see removeFunction).
96 void replaceFunctionWith(Function &OldFn, Function &NewFn);
97
98 /// Remove the call site \p CS from the call graph.
99 void removeCallSite(CallBase &CS);
100
101 /// Replace \p OldCS with the new call site \p NewCS.
102 /// \return True if the replacement was successful, otherwise False. In the
103 /// latter case the parent function of \p OldCB needs to be re-analyzed.
104 bool replaceCallSite(CallBase &OldCS, CallBase &NewCS);
105};
106
107} // end namespace llvm
108
109#endif // LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H
110