include/llvm/Transforms/IPO/Internalize.h

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