xref: /freebsd/contrib/llvm-project/llvm/lib/Transforms/IPO/GlobalDCE.cpp (revision f976241773df2260e6170317080761d1c5814fe5)
1 //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===//
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 transform is designed to eliminate unreachable internal globals from the
10 // program.  It uses an aggressive algorithm, searching out globals that are
11 // known to be alive.  After it finds all of the globals which are needed, it
12 // deletes whatever is left over.  This allows it to delete recursive chunks of
13 // the program which are unreachable.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/Transforms/IPO/GlobalDCE.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/ADT/Statistic.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/IntrinsicInst.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/Pass.h"
24 #include "llvm/Transforms/IPO.h"
25 #include "llvm/Transforms/Utils/CtorUtils.h"
26 #include "llvm/Transforms/Utils/GlobalStatus.h"
27 
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "globaldce"
31 
32 STATISTIC(NumAliases  , "Number of global aliases removed");
33 STATISTIC(NumFunctions, "Number of functions removed");
34 STATISTIC(NumIFuncs,    "Number of indirect functions removed");
35 STATISTIC(NumVariables, "Number of global variables removed");
36 
37 namespace {
38   class GlobalDCELegacyPass : public ModulePass {
39   public:
40     static char ID; // Pass identification, replacement for typeid
41     GlobalDCELegacyPass() : ModulePass(ID) {
42       initializeGlobalDCELegacyPassPass(*PassRegistry::getPassRegistry());
43     }
44 
45     // run - Do the GlobalDCE pass on the specified module, optionally updating
46     // the specified callgraph to reflect the changes.
47     //
48     bool runOnModule(Module &M) override {
49       if (skipModule(M))
50         return false;
51 
52       // We need a minimally functional dummy module analysis manager. It needs
53       // to at least know about the possibility of proxying a function analysis
54       // manager.
55       FunctionAnalysisManager DummyFAM;
56       ModuleAnalysisManager DummyMAM;
57       DummyMAM.registerPass(
58           [&] { return FunctionAnalysisManagerModuleProxy(DummyFAM); });
59 
60       auto PA = Impl.run(M, DummyMAM);
61       return !PA.areAllPreserved();
62     }
63 
64   private:
65     GlobalDCEPass Impl;
66   };
67 }
68 
69 char GlobalDCELegacyPass::ID = 0;
70 INITIALIZE_PASS(GlobalDCELegacyPass, "globaldce",
71                 "Dead Global Elimination", false, false)
72 
73 // Public interface to the GlobalDCEPass.
74 ModulePass *llvm::createGlobalDCEPass() {
75   return new GlobalDCELegacyPass();
76 }
77 
78 /// Returns true if F is effectively empty.
79 static bool isEmptyFunction(Function *F) {
80   BasicBlock &Entry = F->getEntryBlock();
81   for (auto &I : Entry) {
82     if (isa<DbgInfoIntrinsic>(I))
83       continue;
84     if (auto *RI = dyn_cast<ReturnInst>(&I))
85       return !RI->getReturnValue();
86     break;
87   }
88   return false;
89 }
90 
91 /// Compute the set of GlobalValue that depends from V.
92 /// The recursion stops as soon as a GlobalValue is met.
93 void GlobalDCEPass::ComputeDependencies(Value *V,
94                                         SmallPtrSetImpl<GlobalValue *> &Deps) {
95   if (auto *I = dyn_cast<Instruction>(V)) {
96     Function *Parent = I->getParent()->getParent();
97     Deps.insert(Parent);
98   } else if (auto *GV = dyn_cast<GlobalValue>(V)) {
99     Deps.insert(GV);
100   } else if (auto *CE = dyn_cast<Constant>(V)) {
101     // Avoid walking the whole tree of a big ConstantExprs multiple times.
102     auto Where = ConstantDependenciesCache.find(CE);
103     if (Where != ConstantDependenciesCache.end()) {
104       auto const &K = Where->second;
105       Deps.insert(K.begin(), K.end());
106     } else {
107       SmallPtrSetImpl<GlobalValue *> &LocalDeps = ConstantDependenciesCache[CE];
108       for (User *CEUser : CE->users())
109         ComputeDependencies(CEUser, LocalDeps);
110       Deps.insert(LocalDeps.begin(), LocalDeps.end());
111     }
112   }
113 }
114 
115 void GlobalDCEPass::UpdateGVDependencies(GlobalValue &GV) {
116   SmallPtrSet<GlobalValue *, 8> Deps;
117   for (User *User : GV.users())
118     ComputeDependencies(User, Deps);
119   Deps.erase(&GV); // Remove self-reference.
120   for (GlobalValue *GVU : Deps) {
121     GVDependencies[GVU].insert(&GV);
122   }
123 }
124 
125 /// Mark Global value as Live
126 void GlobalDCEPass::MarkLive(GlobalValue &GV,
127                              SmallVectorImpl<GlobalValue *> *Updates) {
128   auto const Ret = AliveGlobals.insert(&GV);
129   if (!Ret.second)
130     return;
131 
132   if (Updates)
133     Updates->push_back(&GV);
134   if (Comdat *C = GV.getComdat()) {
135     for (auto &&CM : make_range(ComdatMembers.equal_range(C)))
136       MarkLive(*CM.second, Updates); // Recursion depth is only two because only
137                                      // globals in the same comdat are visited.
138   }
139 }
140 
141 PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) {
142   bool Changed = false;
143 
144   // The algorithm first computes the set L of global variables that are
145   // trivially live.  Then it walks the initialization of these variables to
146   // compute the globals used to initialize them, which effectively builds a
147   // directed graph where nodes are global variables, and an edge from A to B
148   // means B is used to initialize A.  Finally, it propagates the liveness
149   // information through the graph starting from the nodes in L. Nodes note
150   // marked as alive are discarded.
151 
152   // Remove empty functions from the global ctors list.
153   Changed |= optimizeGlobalCtorsList(M, isEmptyFunction);
154 
155   // Collect the set of members for each comdat.
156   for (Function &F : M)
157     if (Comdat *C = F.getComdat())
158       ComdatMembers.insert(std::make_pair(C, &F));
159   for (GlobalVariable &GV : M.globals())
160     if (Comdat *C = GV.getComdat())
161       ComdatMembers.insert(std::make_pair(C, &GV));
162   for (GlobalAlias &GA : M.aliases())
163     if (Comdat *C = GA.getComdat())
164       ComdatMembers.insert(std::make_pair(C, &GA));
165 
166   // Loop over the module, adding globals which are obviously necessary.
167   for (GlobalObject &GO : M.global_objects()) {
168     Changed |= RemoveUnusedGlobalValue(GO);
169     // Functions with external linkage are needed if they have a body.
170     // Externally visible & appending globals are needed, if they have an
171     // initializer.
172     if (!GO.isDeclaration())
173       if (!GO.isDiscardableIfUnused())
174         MarkLive(GO);
175 
176     UpdateGVDependencies(GO);
177   }
178 
179   // Compute direct dependencies of aliases.
180   for (GlobalAlias &GA : M.aliases()) {
181     Changed |= RemoveUnusedGlobalValue(GA);
182     // Externally visible aliases are needed.
183     if (!GA.isDiscardableIfUnused())
184       MarkLive(GA);
185 
186     UpdateGVDependencies(GA);
187   }
188 
189   // Compute direct dependencies of ifuncs.
190   for (GlobalIFunc &GIF : M.ifuncs()) {
191     Changed |= RemoveUnusedGlobalValue(GIF);
192     // Externally visible ifuncs are needed.
193     if (!GIF.isDiscardableIfUnused())
194       MarkLive(GIF);
195 
196     UpdateGVDependencies(GIF);
197   }
198 
199   // Propagate liveness from collected Global Values through the computed
200   // dependencies.
201   SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(),
202                                            AliveGlobals.end()};
203   while (!NewLiveGVs.empty()) {
204     GlobalValue *LGV = NewLiveGVs.pop_back_val();
205     for (auto *GVD : GVDependencies[LGV])
206       MarkLive(*GVD, &NewLiveGVs);
207   }
208 
209   // Now that all globals which are needed are in the AliveGlobals set, we loop
210   // through the program, deleting those which are not alive.
211   //
212 
213   // The first pass is to drop initializers of global variables which are dead.
214   std::vector<GlobalVariable *> DeadGlobalVars; // Keep track of dead globals
215   for (GlobalVariable &GV : M.globals())
216     if (!AliveGlobals.count(&GV)) {
217       DeadGlobalVars.push_back(&GV);         // Keep track of dead globals
218       if (GV.hasInitializer()) {
219         Constant *Init = GV.getInitializer();
220         GV.setInitializer(nullptr);
221         if (isSafeToDestroyConstant(Init))
222           Init->destroyConstant();
223       }
224     }
225 
226   // The second pass drops the bodies of functions which are dead...
227   std::vector<Function *> DeadFunctions;
228   for (Function &F : M)
229     if (!AliveGlobals.count(&F)) {
230       DeadFunctions.push_back(&F);         // Keep track of dead globals
231       if (!F.isDeclaration())
232         F.deleteBody();
233     }
234 
235   // The third pass drops targets of aliases which are dead...
236   std::vector<GlobalAlias*> DeadAliases;
237   for (GlobalAlias &GA : M.aliases())
238     if (!AliveGlobals.count(&GA)) {
239       DeadAliases.push_back(&GA);
240       GA.setAliasee(nullptr);
241     }
242 
243   // The fourth pass drops targets of ifuncs which are dead...
244   std::vector<GlobalIFunc*> DeadIFuncs;
245   for (GlobalIFunc &GIF : M.ifuncs())
246     if (!AliveGlobals.count(&GIF)) {
247       DeadIFuncs.push_back(&GIF);
248       GIF.setResolver(nullptr);
249     }
250 
251   // Now that all interferences have been dropped, delete the actual objects
252   // themselves.
253   auto EraseUnusedGlobalValue = [&](GlobalValue *GV) {
254     RemoveUnusedGlobalValue(*GV);
255     GV->eraseFromParent();
256     Changed = true;
257   };
258 
259   NumFunctions += DeadFunctions.size();
260   for (Function *F : DeadFunctions)
261     EraseUnusedGlobalValue(F);
262 
263   NumVariables += DeadGlobalVars.size();
264   for (GlobalVariable *GV : DeadGlobalVars)
265     EraseUnusedGlobalValue(GV);
266 
267   NumAliases += DeadAliases.size();
268   for (GlobalAlias *GA : DeadAliases)
269     EraseUnusedGlobalValue(GA);
270 
271   NumIFuncs += DeadIFuncs.size();
272   for (GlobalIFunc *GIF : DeadIFuncs)
273     EraseUnusedGlobalValue(GIF);
274 
275   // Make sure that all memory is released
276   AliveGlobals.clear();
277   ConstantDependenciesCache.clear();
278   GVDependencies.clear();
279   ComdatMembers.clear();
280 
281   if (Changed)
282     return PreservedAnalyses::none();
283   return PreservedAnalyses::all();
284 }
285 
286 // RemoveUnusedGlobalValue - Loop over all of the uses of the specified
287 // GlobalValue, looking for the constant pointer ref that may be pointing to it.
288 // If found, check to see if the constant pointer ref is safe to destroy, and if
289 // so, nuke it.  This will reduce the reference count on the global value, which
290 // might make it deader.
291 //
292 bool GlobalDCEPass::RemoveUnusedGlobalValue(GlobalValue &GV) {
293   if (GV.use_empty())
294     return false;
295   GV.removeDeadConstantUsers();
296   return GV.use_empty();
297 }
298