1 //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This transform is designed to eliminate unreachable internal globals from the
11 // program. It uses an aggressive algorithm, searching out globals that are
12 // known to be alive. After it finds all of the globals which are needed, it
13 // deletes whatever is left over. This allows it to delete recursive chunks of
14 // the program which are unreachable.
16 //===----------------------------------------------------------------------===//
18 #include "llvm/Transforms/IPO/GlobalDCE.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/IR/Instructions.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"
30 #define DEBUG_TYPE "globaldce"
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");
38 class GlobalDCELegacyPass : public ModulePass {
40 static char ID; // Pass identification, replacement for typeid
41 GlobalDCELegacyPass() : ModulePass(ID) {
42 initializeGlobalDCELegacyPassPass(*PassRegistry::getPassRegistry());
45 // run - Do the GlobalDCE pass on the specified module, optionally updating
46 // the specified callgraph to reflect the changes.
48 bool runOnModule(Module &M) override {
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
55 FunctionAnalysisManager DummyFAM;
56 ModuleAnalysisManager DummyMAM;
57 DummyMAM.registerPass(
58 [&] { return FunctionAnalysisManagerModuleProxy(DummyFAM); });
60 auto PA = Impl.run(M, DummyMAM);
61 return !PA.areAllPreserved();
69 char GlobalDCELegacyPass::ID = 0;
70 INITIALIZE_PASS(GlobalDCELegacyPass, "globaldce",
71 "Dead Global Elimination", false, false)
73 // Public interface to the GlobalDCEPass.
74 ModulePass *llvm::createGlobalDCEPass() {
75 return new GlobalDCELegacyPass();
78 /// Returns true if F contains only a single "ret" instruction.
79 static bool isEmptyFunction(Function *F) {
80 BasicBlock &Entry = F->getEntryBlock();
81 if (Entry.size() != 1 || !isa<ReturnInst>(Entry.front()))
83 ReturnInst &RI = cast<ReturnInst>(Entry.front());
84 return RI.getReturnValue() == nullptr;
87 /// Compute the set of GlobalValue that depends from V.
88 /// The recursion stops as soon as a GlobalValue is met.
89 void GlobalDCEPass::ComputeDependencies(Value *V,
90 SmallPtrSetImpl<GlobalValue *> &Deps) {
91 if (auto *I = dyn_cast<Instruction>(V)) {
92 Function *Parent = I->getParent()->getParent();
94 } else if (auto *GV = dyn_cast<GlobalValue>(V)) {
96 } else if (auto *CE = dyn_cast<Constant>(V)) {
97 // Avoid walking the whole tree of a big ConstantExprs multiple times.
98 auto Where = ConstantDependenciesCache.find(CE);
99 if (Where != ConstantDependenciesCache.end()) {
100 auto const &K = Where->second;
101 Deps.insert(K.begin(), K.end());
103 SmallPtrSetImpl<GlobalValue *> &LocalDeps = ConstantDependenciesCache[CE];
104 for (User *CEUser : CE->users())
105 ComputeDependencies(CEUser, LocalDeps);
106 Deps.insert(LocalDeps.begin(), LocalDeps.end());
111 void GlobalDCEPass::UpdateGVDependencies(GlobalValue &GV) {
112 SmallPtrSet<GlobalValue *, 8> Deps;
113 for (User *User : GV.users())
114 ComputeDependencies(User, Deps);
115 Deps.erase(&GV); // Remove self-reference.
116 for (GlobalValue *GVU : Deps) {
117 GVDependencies[GVU].insert(&GV);
121 /// Mark Global value as Live
122 void GlobalDCEPass::MarkLive(GlobalValue &GV,
123 SmallVectorImpl<GlobalValue *> *Updates) {
124 auto const Ret = AliveGlobals.insert(&GV);
129 Updates->push_back(&GV);
130 if (Comdat *C = GV.getComdat()) {
131 for (auto &&CM : make_range(ComdatMembers.equal_range(C)))
132 MarkLive(*CM.second, Updates); // Recursion depth is only two because only
133 // globals in the same comdat are visited.
137 PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) {
138 bool Changed = false;
140 // The algorithm first computes the set L of global variables that are
141 // trivially live. Then it walks the initialization of these variables to
142 // compute the globals used to initialize them, which effectively builds a
143 // directed graph where nodes are global variables, and an edge from A to B
144 // means B is used to initialize A. Finally, it propagates the liveness
145 // information through the graph starting from the nodes in L. Nodes note
146 // marked as alive are discarded.
148 // Remove empty functions from the global ctors list.
149 Changed |= optimizeGlobalCtorsList(M, isEmptyFunction);
151 // Collect the set of members for each comdat.
152 for (Function &F : M)
153 if (Comdat *C = F.getComdat())
154 ComdatMembers.insert(std::make_pair(C, &F));
155 for (GlobalVariable &GV : M.globals())
156 if (Comdat *C = GV.getComdat())
157 ComdatMembers.insert(std::make_pair(C, &GV));
158 for (GlobalAlias &GA : M.aliases())
159 if (Comdat *C = GA.getComdat())
160 ComdatMembers.insert(std::make_pair(C, &GA));
162 // Loop over the module, adding globals which are obviously necessary.
163 for (GlobalObject &GO : M.global_objects()) {
164 Changed |= RemoveUnusedGlobalValue(GO);
165 // Functions with external linkage are needed if they have a body.
166 // Externally visible & appending globals are needed, if they have an
168 if (!GO.isDeclaration() && !GO.hasAvailableExternallyLinkage())
169 if (!GO.isDiscardableIfUnused())
172 UpdateGVDependencies(GO);
175 // Compute direct dependencies of aliases.
176 for (GlobalAlias &GA : M.aliases()) {
177 Changed |= RemoveUnusedGlobalValue(GA);
178 // Externally visible aliases are needed.
179 if (!GA.isDiscardableIfUnused())
182 UpdateGVDependencies(GA);
185 // Compute direct dependencies of ifuncs.
186 for (GlobalIFunc &GIF : M.ifuncs()) {
187 Changed |= RemoveUnusedGlobalValue(GIF);
188 // Externally visible ifuncs are needed.
189 if (!GIF.isDiscardableIfUnused())
192 UpdateGVDependencies(GIF);
195 // Propagate liveness from collected Global Values through the computed
197 SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(),
199 while (!NewLiveGVs.empty()) {
200 GlobalValue *LGV = NewLiveGVs.pop_back_val();
201 for (auto *GVD : GVDependencies[LGV])
202 MarkLive(*GVD, &NewLiveGVs);
205 // Now that all globals which are needed are in the AliveGlobals set, we loop
206 // through the program, deleting those which are not alive.
209 // The first pass is to drop initializers of global variables which are dead.
210 std::vector<GlobalVariable *> DeadGlobalVars; // Keep track of dead globals
211 for (GlobalVariable &GV : M.globals())
212 if (!AliveGlobals.count(&GV)) {
213 DeadGlobalVars.push_back(&GV); // Keep track of dead globals
214 if (GV.hasInitializer()) {
215 Constant *Init = GV.getInitializer();
216 GV.setInitializer(nullptr);
217 if (isSafeToDestroyConstant(Init))
218 Init->destroyConstant();
222 // The second pass drops the bodies of functions which are dead...
223 std::vector<Function *> DeadFunctions;
224 for (Function &F : M)
225 if (!AliveGlobals.count(&F)) {
226 DeadFunctions.push_back(&F); // Keep track of dead globals
227 if (!F.isDeclaration())
231 // The third pass drops targets of aliases which are dead...
232 std::vector<GlobalAlias*> DeadAliases;
233 for (GlobalAlias &GA : M.aliases())
234 if (!AliveGlobals.count(&GA)) {
235 DeadAliases.push_back(&GA);
236 GA.setAliasee(nullptr);
239 // The fourth pass drops targets of ifuncs which are dead...
240 std::vector<GlobalIFunc*> DeadIFuncs;
241 for (GlobalIFunc &GIF : M.ifuncs())
242 if (!AliveGlobals.count(&GIF)) {
243 DeadIFuncs.push_back(&GIF);
244 GIF.setResolver(nullptr);
247 // Now that all interferences have been dropped, delete the actual objects
249 auto EraseUnusedGlobalValue = [&](GlobalValue *GV) {
250 RemoveUnusedGlobalValue(*GV);
251 GV->eraseFromParent();
255 NumFunctions += DeadFunctions.size();
256 for (Function *F : DeadFunctions)
257 EraseUnusedGlobalValue(F);
259 NumVariables += DeadGlobalVars.size();
260 for (GlobalVariable *GV : DeadGlobalVars)
261 EraseUnusedGlobalValue(GV);
263 NumAliases += DeadAliases.size();
264 for (GlobalAlias *GA : DeadAliases)
265 EraseUnusedGlobalValue(GA);
267 NumIFuncs += DeadIFuncs.size();
268 for (GlobalIFunc *GIF : DeadIFuncs)
269 EraseUnusedGlobalValue(GIF);
271 // Make sure that all memory is released
272 AliveGlobals.clear();
273 ConstantDependenciesCache.clear();
274 GVDependencies.clear();
275 ComdatMembers.clear();
278 return PreservedAnalyses::none();
279 return PreservedAnalyses::all();
282 // RemoveUnusedGlobalValue - Loop over all of the uses of the specified
283 // GlobalValue, looking for the constant pointer ref that may be pointing to it.
284 // If found, check to see if the constant pointer ref is safe to destroy, and if
285 // so, nuke it. This will reduce the reference count on the global value, which
286 // might make it deader.
288 bool GlobalDCEPass::RemoveUnusedGlobalValue(GlobalValue &GV) {
291 GV.removeDeadConstantUsers();
292 return GV.use_empty();