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/LazyCallGraph.h" 20 21 namespace llvm { 22 23 class CallGraph; 24 class 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. 29 class CallGraphUpdater { 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 /// Old PM variables 42 ///{ 43 CallGraph *CG = nullptr; 44 CallGraphSCC *CGSCC = nullptr; 45 ///} 46 47 /// New PM variables 48 ///{ 49 LazyCallGraph *LCG = nullptr; 50 LazyCallGraph::SCC *SCC = nullptr; 51 CGSCCAnalysisManager *AM = nullptr; 52 CGSCCUpdateResult *UR = nullptr; 53 FunctionAnalysisManager *FAM = nullptr; 54 ///} 55 56 public: 57 CallGraphUpdater() = default; 58 ~CallGraphUpdater() { finalize(); } 59 60 /// Initializers for usage outside of a CGSCC pass, inside a CGSCC pass in 61 /// the old and new pass manager (PM). 62 ///{ 63 void initialize(CallGraph &CG, CallGraphSCC &SCC) { 64 this->CG = &CG; 65 this->CGSCC = &SCC; 66 } 67 void initialize(LazyCallGraph &LCG, LazyCallGraph::SCC &SCC, 68 CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR) { 69 this->LCG = &LCG; 70 this->SCC = &SCC; 71 this->AM = &AM; 72 this->UR = &UR; 73 FAM = 74 &AM.getResult<FunctionAnalysisManagerCGSCCProxy>(SCC, LCG).getManager(); 75 } 76 ///} 77 78 /// Finalizer that will trigger actions like function removal from the CG. 79 bool finalize(); 80 81 /// Remove \p Fn from the call graph. 82 void removeFunction(Function &Fn); 83 84 /// After an CGSCC pass changes a function in ways that affect the call 85 /// graph, this method can be called to update it. 86 void reanalyzeFunction(Function &Fn); 87 88 /// If a new function was created by outlining, this method can be called 89 /// to update the call graph for the new function. Note that the old one 90 /// still needs to be re-analyzed or manually updated. 91 void registerOutlinedFunction(Function &OriginalFn, Function &NewFn); 92 93 /// Replace \p OldFn in the call graph (and SCC) with \p NewFn. The uses 94 /// outside the call graph and the function \p OldFn are not modified. 95 /// Note that \p OldFn is also removed from the call graph 96 /// (\see removeFunction). 97 void replaceFunctionWith(Function &OldFn, Function &NewFn); 98 99 /// Remove the call site \p CS from the call graph. 100 void removeCallSite(CallBase &CS); 101 102 /// Replace \p OldCS with the new call site \p NewCS. 103 /// \return True if the replacement was successful, otherwise False. In the 104 /// latter case the parent function of \p OldCB needs to be re-analyzed. 105 bool replaceCallSite(CallBase &OldCS, CallBase &NewCS); 106 }; 107 108 } // end namespace llvm 109 110 #endif // LLVM_TRANSFORMS_UTILS_CALLGRAPHUPDATER_H 111