1 //===-- Internalize.cpp - Mark functions internal -------------------------===//
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 #include "llvm/Transforms/IPO/Internalize.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/Statistic.h"
24 #include "llvm/ADT/StringSet.h"
25 #include "llvm/ADT/Triple.h"
26 #include "llvm/Analysis/CallGraph.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/InitializePasses.h"
29 #include "llvm/Pass.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/LineIterator.h"
33 #include "llvm/Support/MemoryBuffer.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include "llvm/Transforms/IPO.h"
36 #include "llvm/Transforms/Utils/GlobalStatus.h"
37 #include "llvm/Transforms/Utils/ModuleUtils.h"
38 using namespace llvm;
39
40 #define DEBUG_TYPE "internalize"
41
42 STATISTIC(NumAliases, "Number of aliases internalized");
43 STATISTIC(NumFunctions, "Number of functions internalized");
44 STATISTIC(NumGlobals, "Number of global vars internalized");
45
46 // APIFile - A file which contains a list of symbols that should not be marked
47 // external.
48 static cl::opt<std::string>
49 APIFile("internalize-public-api-file", cl::value_desc("filename"),
50 cl::desc("A file containing list of symbol names to preserve"));
51
52 // APIList - A list of symbols that should not be marked internal.
53 static cl::list<std::string>
54 APIList("internalize-public-api-list", cl::value_desc("list"),
55 cl::desc("A list of symbol names to preserve"), cl::CommaSeparated);
56
57 namespace {
58 // Helper to load an API list to preserve from file and expose it as a functor
59 // for internalization.
60 class PreserveAPIList {
61 public:
PreserveAPIList()62 PreserveAPIList() {
63 if (!APIFile.empty())
64 LoadFile(APIFile);
65 ExternalNames.insert(APIList.begin(), APIList.end());
66 }
67
operator ()(const GlobalValue & GV)68 bool operator()(const GlobalValue &GV) {
69 return ExternalNames.count(GV.getName());
70 }
71
72 private:
73 // Contains the set of symbols loaded from file
74 StringSet<> ExternalNames;
75
LoadFile(StringRef Filename)76 void LoadFile(StringRef Filename) {
77 // Load the APIFile...
78 ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
79 MemoryBuffer::getFile(Filename);
80 if (!Buf) {
81 errs() << "WARNING: Internalize couldn't load file '" << Filename
82 << "'! Continuing as if it's empty.\n";
83 return; // Just continue as if the file were empty
84 }
85 for (line_iterator I(*Buf->get(), true), E; I != E; ++I)
86 ExternalNames.insert(*I);
87 }
88 };
89 } // end anonymous namespace
90
shouldPreserveGV(const GlobalValue & GV)91 bool InternalizePass::shouldPreserveGV(const GlobalValue &GV) {
92 // Function must be defined here
93 if (GV.isDeclaration())
94 return true;
95
96 // Available externally is really just a "declaration with a body".
97 if (GV.hasAvailableExternallyLinkage())
98 return true;
99
100 // Assume that dllexported symbols are referenced elsewhere
101 if (GV.hasDLLExportStorageClass())
102 return true;
103
104 // As the name suggests, externally initialized variables need preserving as
105 // they would be initialized elsewhere externally.
106 if (const auto *G = dyn_cast<GlobalVariable>(&GV))
107 if (G->isExternallyInitialized())
108 return true;
109
110 // Already local, has nothing to do.
111 if (GV.hasLocalLinkage())
112 return false;
113
114 // Check some special cases
115 if (AlwaysPreserved.count(GV.getName()))
116 return true;
117
118 return MustPreserveGV(GV);
119 }
120
maybeInternalize(GlobalValue & GV,DenseMap<const Comdat *,ComdatInfo> & ComdatMap)121 bool InternalizePass::maybeInternalize(
122 GlobalValue &GV, DenseMap<const Comdat *, ComdatInfo> &ComdatMap) {
123 SmallString<0> ComdatName;
124 if (Comdat *C = GV.getComdat()) {
125 // For GlobalAlias, C is the aliasee object's comdat which may have been
126 // redirected. So ComdatMap may not contain C.
127 if (ComdatMap.lookup(C).External)
128 return false;
129
130 if (auto *GO = dyn_cast<GlobalObject>(&GV)) {
131 // If a comdat with one member is not externally visible, we can drop it.
132 // Otherwise, the comdat can be used to establish dependencies among the
133 // group of sections. Thus we have to keep the comdat but switch it to
134 // nodeduplicate.
135 // Note: nodeduplicate is not necessary for COFF. wasm doesn't support
136 // nodeduplicate.
137 ComdatInfo &Info = ComdatMap.find(C)->second;
138 if (Info.Size == 1)
139 GO->setComdat(nullptr);
140 else if (!IsWasm)
141 C->setSelectionKind(Comdat::NoDeduplicate);
142 }
143
144 if (GV.hasLocalLinkage())
145 return false;
146 } else {
147 if (GV.hasLocalLinkage())
148 return false;
149
150 if (shouldPreserveGV(GV))
151 return false;
152 }
153
154 GV.setVisibility(GlobalValue::DefaultVisibility);
155 GV.setLinkage(GlobalValue::InternalLinkage);
156 return true;
157 }
158
159 // If GV is part of a comdat and is externally visible, update the comdat size
160 // and keep track of its comdat so that we don't internalize any of its members.
checkComdat(GlobalValue & GV,DenseMap<const Comdat *,ComdatInfo> & ComdatMap)161 void InternalizePass::checkComdat(
162 GlobalValue &GV, DenseMap<const Comdat *, ComdatInfo> &ComdatMap) {
163 Comdat *C = GV.getComdat();
164 if (!C)
165 return;
166
167 ComdatInfo &Info = ComdatMap.try_emplace(C).first->second;
168 ++Info.Size;
169 if (shouldPreserveGV(GV))
170 Info.External = true;
171 }
172
internalizeModule(Module & M,CallGraph * CG)173 bool InternalizePass::internalizeModule(Module &M, CallGraph *CG) {
174 bool Changed = false;
175 CallGraphNode *ExternalNode = CG ? CG->getExternalCallingNode() : nullptr;
176
177 SmallVector<GlobalValue *, 4> Used;
178 collectUsedGlobalVariables(M, Used, false);
179
180 // Collect comdat size and visiblity information for the module.
181 DenseMap<const Comdat *, ComdatInfo> ComdatMap;
182 if (!M.getComdatSymbolTable().empty()) {
183 for (Function &F : M)
184 checkComdat(F, ComdatMap);
185 for (GlobalVariable &GV : M.globals())
186 checkComdat(GV, ComdatMap);
187 for (GlobalAlias &GA : M.aliases())
188 checkComdat(GA, ComdatMap);
189 }
190
191 // We must assume that globals in llvm.used have a reference that not even
192 // the linker can see, so we don't internalize them.
193 // For llvm.compiler.used the situation is a bit fuzzy. The assembler and
194 // linker can drop those symbols. If this pass is running as part of LTO,
195 // one might think that it could just drop llvm.compiler.used. The problem
196 // is that even in LTO llvm doesn't see every reference. For example,
197 // we don't see references from function local inline assembly. To be
198 // conservative, we internalize symbols in llvm.compiler.used, but we
199 // keep llvm.compiler.used so that the symbol is not deleted by llvm.
200 for (GlobalValue *V : Used) {
201 AlwaysPreserved.insert(V->getName());
202 }
203
204 // Mark all functions not in the api as internal.
205 IsWasm = Triple(M.getTargetTriple()).isOSBinFormatWasm();
206 for (Function &I : M) {
207 if (!maybeInternalize(I, ComdatMap))
208 continue;
209 Changed = true;
210
211 if (ExternalNode)
212 // Remove a callgraph edge from the external node to this function.
213 ExternalNode->removeOneAbstractEdgeTo((*CG)[&I]);
214
215 ++NumFunctions;
216 LLVM_DEBUG(dbgs() << "Internalizing func " << I.getName() << "\n");
217 }
218
219 // Never internalize the llvm.used symbol. It is used to implement
220 // attribute((used)).
221 // FIXME: Shouldn't this just filter on llvm.metadata section??
222 AlwaysPreserved.insert("llvm.used");
223 AlwaysPreserved.insert("llvm.compiler.used");
224
225 // Never internalize anchors used by the machine module info, else the info
226 // won't find them. (see MachineModuleInfo.)
227 AlwaysPreserved.insert("llvm.global_ctors");
228 AlwaysPreserved.insert("llvm.global_dtors");
229 AlwaysPreserved.insert("llvm.global.annotations");
230
231 // Never internalize symbols code-gen inserts.
232 // FIXME: We should probably add this (and the __stack_chk_guard) via some
233 // type of call-back in CodeGen.
234 AlwaysPreserved.insert("__stack_chk_fail");
235 if (Triple(M.getTargetTriple()).isOSAIX())
236 AlwaysPreserved.insert("__ssp_canary_word");
237 else
238 AlwaysPreserved.insert("__stack_chk_guard");
239
240 // Mark all global variables with initializers that are not in the api as
241 // internal as well.
242 for (auto &GV : M.globals()) {
243 if (!maybeInternalize(GV, ComdatMap))
244 continue;
245 Changed = true;
246
247 ++NumGlobals;
248 LLVM_DEBUG(dbgs() << "Internalized gvar " << GV.getName() << "\n");
249 }
250
251 // Mark all aliases that are not in the api as internal as well.
252 for (auto &GA : M.aliases()) {
253 if (!maybeInternalize(GA, ComdatMap))
254 continue;
255 Changed = true;
256
257 ++NumAliases;
258 LLVM_DEBUG(dbgs() << "Internalized alias " << GA.getName() << "\n");
259 }
260
261 return Changed;
262 }
263
InternalizePass()264 InternalizePass::InternalizePass() : MustPreserveGV(PreserveAPIList()) {}
265
run(Module & M,ModuleAnalysisManager & AM)266 PreservedAnalyses InternalizePass::run(Module &M, ModuleAnalysisManager &AM) {
267 if (!internalizeModule(M, AM.getCachedResult<CallGraphAnalysis>(M)))
268 return PreservedAnalyses::all();
269
270 PreservedAnalyses PA;
271 PA.preserve<CallGraphAnalysis>();
272 return PA;
273 }
274
275 namespace {
276 class InternalizeLegacyPass : public ModulePass {
277 // Client supplied callback to control wheter a symbol must be preserved.
278 std::function<bool(const GlobalValue &)> MustPreserveGV;
279
280 public:
281 static char ID; // Pass identification, replacement for typeid
282
InternalizeLegacyPass()283 InternalizeLegacyPass() : ModulePass(ID), MustPreserveGV(PreserveAPIList()) {}
284
InternalizeLegacyPass(std::function<bool (const GlobalValue &)> MustPreserveGV)285 InternalizeLegacyPass(std::function<bool(const GlobalValue &)> MustPreserveGV)
286 : ModulePass(ID), MustPreserveGV(std::move(MustPreserveGV)) {
287 initializeInternalizeLegacyPassPass(*PassRegistry::getPassRegistry());
288 }
289
runOnModule(Module & M)290 bool runOnModule(Module &M) override {
291 if (skipModule(M))
292 return false;
293
294 CallGraphWrapperPass *CGPass =
295 getAnalysisIfAvailable<CallGraphWrapperPass>();
296 CallGraph *CG = CGPass ? &CGPass->getCallGraph() : nullptr;
297 return internalizeModule(M, MustPreserveGV, CG);
298 }
299
getAnalysisUsage(AnalysisUsage & AU) const300 void getAnalysisUsage(AnalysisUsage &AU) const override {
301 AU.setPreservesCFG();
302 AU.addPreserved<CallGraphWrapperPass>();
303 }
304 };
305 }
306
307 char InternalizeLegacyPass::ID = 0;
308 INITIALIZE_PASS(InternalizeLegacyPass, "internalize",
309 "Internalize Global Symbols", false, false)
310
createInternalizePass()311 ModulePass *llvm::createInternalizePass() {
312 return new InternalizeLegacyPass();
313 }
314
createInternalizePass(std::function<bool (const GlobalValue &)> MustPreserveGV)315 ModulePass *llvm::createInternalizePass(
316 std::function<bool(const GlobalValue &)> MustPreserveGV) {
317 return new InternalizeLegacyPass(std::move(MustPreserveGV));
318 }
319