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/DenseMap.h"
25 #include "llvm/ADT/StringSet.h"
26 #include "llvm/IR/PassManager.h"
27 #include <functional>
28
29 namespace llvm {
30 class Module;
31
32 /// A pass that internalizes all functions and variables other than those that
33 /// must be preserved according to \c MustPreserveGV.
34 class InternalizePass : public PassInfoMixin<InternalizePass> {
35 struct ComdatInfo {
36 // The number of members. A comdat with one member which is not externally
37 // visible can be freely dropped.
38 size_t Size = 0;
39 // Whether the comdat has an externally visible member.
40 bool External = false;
41 };
42
43 bool IsWasm = false;
44
45 /// Client supplied callback to control wheter a symbol must be preserved.
46 const std::function<bool(const GlobalValue &)> MustPreserveGV;
47 /// Set of symbols private to the compiler that this pass should not touch.
48 StringSet<> AlwaysPreserved;
49
50 /// Return false if we're allowed to internalize this GV.
51 bool shouldPreserveGV(const GlobalValue &GV);
52 /// Internalize GV if it is possible to do so, i.e. it is not externally
53 /// visible and is not a member of an externally visible comdat.
54 bool maybeInternalize(GlobalValue &GV,
55 DenseMap<const Comdat *, ComdatInfo> &ComdatMap);
56 /// If GV is part of a comdat and is externally visible, keep track of its
57 /// comdat so that we don't internalize any of its members.
58 void checkComdat(GlobalValue &GV,
59 DenseMap<const Comdat *, ComdatInfo> &ComdatMap);
60
61 public:
62 InternalizePass();
InternalizePass(std::function<bool (const GlobalValue &)> MustPreserveGV)63 InternalizePass(std::function<bool(const GlobalValue &)> MustPreserveGV)
64 : MustPreserveGV(std::move(MustPreserveGV)) {}
65
66 /// Run the internalizer on \p TheModule, returns true if any changes was
67 /// made.
68 bool internalizeModule(Module &TheModule);
69
70 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
71 };
72
73 /// Helper function to internalize functions and variables in a Module.
74 inline bool
internalizeModule(Module & TheModule,std::function<bool (const GlobalValue &)> MustPreserveGV)75 internalizeModule(Module &TheModule,
76 std::function<bool(const GlobalValue &)> MustPreserveGV) {
77 return InternalizePass(std::move(MustPreserveGV))
78 .internalizeModule(TheModule);
79 }
80 } // end namespace llvm
81
82 #endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H
83