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