1 //====- Internalize.h - Internalization API ---------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This pass loops over all of the functions and variables in the input module. 11 // If the function or variable does not need to be preserved according to the 12 // client supplied callback, it is marked as internal. 13 // 14 // This transformation would not be legal in a regular compilation, but it gets 15 // extra information from the linker about what is safe. 16 // 17 // For example: Internalizing a function with external linkage. Only if we are 18 // told it is only used from within this module, it is safe to do it. 19 // 20 //===----------------------------------------------------------------------===// 21 22 #ifndef LLVM_TRANSFORMS_IPO_INTERNALIZE_H 23 #define LLVM_TRANSFORMS_IPO_INTERNALIZE_H 24 25 #include "llvm/ADT/StringSet.h" 26 #include "llvm/IR/GlobalValue.h" 27 #include "llvm/IR/PassManager.h" 28 #include <functional> 29 #include <set> 30 31 namespace llvm { 32 class Module; 33 class CallGraph; 34 35 /// A pass that internalizes all functions and variables other than those that 36 /// must be preserved according to \c MustPreserveGV. 37 class InternalizePass : public PassInfoMixin<InternalizePass> { 38 /// Client supplied callback to control wheter a symbol must be preserved. 39 const std::function<bool(const GlobalValue &)> MustPreserveGV; 40 /// Set of symbols private to the compiler that this pass should not touch. 41 StringSet<> AlwaysPreserved; 42 43 /// Return false if we're allowed to internalize this GV. 44 bool shouldPreserveGV(const GlobalValue &GV); 45 /// Internalize GV if it is possible to do so, i.e. it is not externally 46 /// visible and is not a member of an externally visible comdat. 47 bool maybeInternalize(GlobalValue &GV, 48 const std::set<const Comdat *> &ExternalComdats); 49 /// If GV is part of a comdat and is externally visible, keep track of its 50 /// comdat so that we don't internalize any of its members. 51 void checkComdatVisibility(GlobalValue &GV, 52 std::set<const Comdat *> &ExternalComdats); 53 54 public: 55 InternalizePass(); 56 InternalizePass(std::function<bool(const GlobalValue &)> MustPreserveGV) 57 : MustPreserveGV(std::move(MustPreserveGV)) {} 58 59 /// Run the internalizer on \p TheModule, returns true if any changes was 60 /// made. 61 /// 62 /// If the CallGraph \p CG is supplied, it will be updated when 63 /// internalizing a function (by removing any edge from the "external node") 64 bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr); 65 66 PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); 67 }; 68 69 /// Helper function to internalize functions and variables in a Module. 70 inline bool 71 internalizeModule(Module &TheModule, 72 std::function<bool(const GlobalValue &)> MustPreserveGV, 73 CallGraph *CG = nullptr) { 74 return InternalizePass(std::move(MustPreserveGV)) 75 .internalizeModule(TheModule, CG); 76 } 77 } // end namespace llvm 78 79 #endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H 80
