Chris Lattner | 62b7fd1 | 2002-04-07 20:49:59 +0000 | [diff] [blame] | 1 | //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===// |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | f3ebc3f | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 482202a | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | bd422e6 | 2001-11-26 18:42:17 +0000 | [diff] [blame] | 9 | // |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 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. |
Chris Lattner | bd422e6 | 2001-11-26 18:42:17 +0000 | [diff] [blame] | 15 | // |
| 16 | //===----------------------------------------------------------------------===// |
| 17 | |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 18 | #include "llvm/Transforms/IPO/GlobalDCE.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/SmallPtrSet.h" |
| 20 | #include "llvm/ADT/Statistic.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 21 | #include "llvm/IR/Constants.h" |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 22 | #include "llvm/IR/Instructions.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 23 | #include "llvm/IR/Module.h" |
Mehdi Amini | b550cb1 | 2016-04-18 09:17:29 +0000 | [diff] [blame] | 24 | #include "llvm/Pass.h" |
| 25 | #include "llvm/Transforms/IPO.h" |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 26 | #include "llvm/Transforms/Utils/CtorUtils.h" |
Bruno Cardoso Lopes | e2a1fa3 | 2014-08-25 17:51:14 +0000 | [diff] [blame] | 27 | #include "llvm/Transforms/Utils/GlobalStatus.h" |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 28 | |
Chris Lattner | f52e03c | 2003-11-21 21:54:22 +0000 | [diff] [blame] | 29 | using namespace llvm; |
Brian Gaeke | 960707c | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 30 | |
Chandler Carruth | 964daaa | 2014-04-22 02:55:47 +0000 | [diff] [blame] | 31 | #define DEBUG_TYPE "globaldce" |
| 32 | |
Duncan Sands | 821d13c | 2009-01-05 20:39:50 +0000 | [diff] [blame] | 33 | STATISTIC(NumAliases , "Number of global aliases removed"); |
Chris Lattner | 1631bcb | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 34 | STATISTIC(NumFunctions, "Number of functions removed"); |
David Majnemer | 9554949 | 2016-05-04 00:20:48 +0000 | [diff] [blame] | 35 | STATISTIC(NumIFuncs, "Number of indirect functions removed"); |
Chris Lattner | 1631bcb | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 36 | STATISTIC(NumVariables, "Number of global variables removed"); |
Chris Lattner | bf3a099 | 2002-10-01 22:38:41 +0000 | [diff] [blame] | 37 | |
Chris Lattner | 1631bcb | 2006-12-19 22:09:18 +0000 | [diff] [blame] | 38 | namespace { |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 39 | class GlobalDCELegacyPass : public ModulePass { |
| 40 | public: |
Nick Lewycky | e7da2d6 | 2007-05-06 13:37:16 +0000 | [diff] [blame] | 41 | static char ID; // Pass identification, replacement for typeid |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 42 | GlobalDCELegacyPass() : ModulePass(ID) { |
| 43 | initializeGlobalDCELegacyPassPass(*PassRegistry::getPassRegistry()); |
Owen Anderson | 6c18d1a | 2010-10-19 17:21:58 +0000 | [diff] [blame] | 44 | } |
Duncan Sands | f5dbbae | 2009-01-05 20:37:33 +0000 | [diff] [blame] | 45 | |
Chris Lattner | 04805fa | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 46 | // run - Do the GlobalDCE pass on the specified module, optionally updating |
| 47 | // the specified callgraph to reflect the changes. |
| 48 | // |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 49 | bool runOnModule(Module &M) override { |
| 50 | if (skipModule(M)) |
| 51 | return false; |
| 52 | |
Chandler Carruth | e8c66b2 | 2017-01-23 08:33:24 +0000 | [diff] [blame] | 53 | // We need a minimally functional dummy module analysis manager. It needs |
| 54 | // to at least know about the possibility of proxying a function analysis |
| 55 | // manager. |
| 56 | FunctionAnalysisManager DummyFAM; |
Chandler Carruth | 164a2aa6 | 2016-06-17 00:11:01 +0000 | [diff] [blame] | 57 | ModuleAnalysisManager DummyMAM; |
Chandler Carruth | e8c66b2 | 2017-01-23 08:33:24 +0000 | [diff] [blame] | 58 | DummyMAM.registerPass( |
| 59 | [&] { return FunctionAnalysisManagerModuleProxy(DummyFAM); }); |
| 60 | |
Chandler Carruth | 164a2aa6 | 2016-06-17 00:11:01 +0000 | [diff] [blame] | 61 | auto PA = Impl.run(M, DummyMAM); |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 62 | return !PA.areAllPreserved(); |
| 63 | } |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 64 | |
| 65 | private: |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 66 | GlobalDCEPass Impl; |
Chris Lattner | 04805fa | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 67 | }; |
Alexander Kornienko | f00654e | 2015-06-23 09:49:53 +0000 | [diff] [blame] | 68 | } |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 69 | |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 70 | char GlobalDCELegacyPass::ID = 0; |
| 71 | INITIALIZE_PASS(GlobalDCELegacyPass, "globaldce", |
| 72 | "Dead Global Elimination", false, false) |
| 73 | |
| 74 | // Public interface to the GlobalDCEPass. |
| 75 | ModulePass *llvm::createGlobalDCEPass() { |
| 76 | return new GlobalDCELegacyPass(); |
| 77 | } |
| 78 | |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 79 | /// Returns true if F contains only a single "ret" instruction. |
Richard Smith | c167d65 | 2014-05-06 01:44:26 +0000 | [diff] [blame] | 80 | static bool isEmptyFunction(Function *F) { |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 81 | BasicBlock &Entry = F->getEntryBlock(); |
| 82 | if (Entry.size() != 1 || !isa<ReturnInst>(Entry.front())) |
| 83 | return false; |
| 84 | ReturnInst &RI = cast<ReturnInst>(Entry.front()); |
Craig Topper | 66f09ad | 2014-06-08 22:29:17 +0000 | [diff] [blame] | 85 | return RI.getReturnValue() == nullptr; |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 86 | } |
Chris Lattner | d5d5678 | 2002-01-31 00:45:11 +0000 | [diff] [blame] | 87 | |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 88 | /// Compute the set of GlobalValue that depends from V. |
| 89 | /// The recursion stops as soon as a GlobalValue is met. |
| 90 | void GlobalDCEPass::ComputeDependencies(Value *V, |
| 91 | SmallPtrSetImpl<GlobalValue *> &Deps) { |
| 92 | if (auto *I = dyn_cast<Instruction>(V)) { |
| 93 | Function *Parent = I->getParent()->getParent(); |
| 94 | Deps.insert(Parent); |
| 95 | } else if (auto *GV = dyn_cast<GlobalValue>(V)) { |
| 96 | Deps.insert(GV); |
| 97 | } else if (auto *CE = dyn_cast<Constant>(V)) { |
| 98 | // Avoid walking the whole tree of a big ConstantExprs multiple times. |
| 99 | auto Where = ConstantDependenciesCache.find(CE); |
| 100 | if (Where != ConstantDependenciesCache.end()) { |
| 101 | auto const &K = Where->second; |
| 102 | Deps.insert(K.begin(), K.end()); |
| 103 | } else { |
| 104 | SmallPtrSetImpl<GlobalValue *> &LocalDeps = ConstantDependenciesCache[CE]; |
| 105 | for (User *CEUser : CE->users()) |
| 106 | ComputeDependencies(CEUser, LocalDeps); |
| 107 | Deps.insert(LocalDeps.begin(), LocalDeps.end()); |
| 108 | } |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | void GlobalDCEPass::UpdateGVDependencies(GlobalValue &GV) { |
| 113 | SmallPtrSet<GlobalValue *, 8> Deps; |
| 114 | for (User *User : GV.users()) |
| 115 | ComputeDependencies(User, Deps); |
| 116 | Deps.erase(&GV); // Remove self-reference. |
| 117 | for (GlobalValue *GVU : Deps) { |
| 118 | GVDependencies.insert(std::make_pair(GVU, &GV)); |
| 119 | } |
| 120 | } |
| 121 | |
| 122 | /// Mark Global value as Live |
| 123 | void GlobalDCEPass::MarkLive(GlobalValue &GV, |
| 124 | SmallVectorImpl<GlobalValue *> *Updates) { |
| 125 | auto const Ret = AliveGlobals.insert(&GV); |
| 126 | if (!Ret.second) |
| 127 | return; |
| 128 | |
| 129 | if (Updates) |
| 130 | Updates->push_back(&GV); |
| 131 | if (Comdat *C = GV.getComdat()) { |
| 132 | for (auto &&CM : make_range(ComdatMembers.equal_range(C))) |
| 133 | MarkLive(*CM.second, Updates); // Recursion depth is only two because only |
| 134 | // globals in the same comdat are visited. |
| 135 | } |
| 136 | } |
| 137 | |
Chandler Carruth | e8c66b2 | 2017-01-23 08:33:24 +0000 | [diff] [blame] | 138 | PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) { |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 139 | bool Changed = false; |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 140 | |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 141 | // The algorithm first computes the set L of global variables that are |
| 142 | // trivially live. Then it walks the initialization of these variables to |
| 143 | // compute the globals used to initialize them, which effectively builds a |
| 144 | // directed graph where nodes are global variables, and an edge from A to B |
| 145 | // means B is used to initialize A. Finally, it propagates the liveness |
| 146 | // information through the graph starting from the nodes in L. Nodes note |
| 147 | // marked as alive are discarded. |
| 148 | |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 149 | // Remove empty functions from the global ctors list. |
Richard Smith | c167d65 | 2014-05-06 01:44:26 +0000 | [diff] [blame] | 150 | Changed |= optimizeGlobalCtorsList(M, isEmptyFunction); |
Nico Weber | 4b2acde | 2014-05-02 18:35:25 +0000 | [diff] [blame] | 151 | |
Peter Collingbourne | 0dbc708 | 2015-03-19 18:23:29 +0000 | [diff] [blame] | 152 | // Collect the set of members for each comdat. |
| 153 | for (Function &F : M) |
| 154 | if (Comdat *C = F.getComdat()) |
| 155 | ComdatMembers.insert(std::make_pair(C, &F)); |
| 156 | for (GlobalVariable &GV : M.globals()) |
| 157 | if (Comdat *C = GV.getComdat()) |
| 158 | ComdatMembers.insert(std::make_pair(C, &GV)); |
| 159 | for (GlobalAlias &GA : M.aliases()) |
| 160 | if (Comdat *C = GA.getComdat()) |
| 161 | ComdatMembers.insert(std::make_pair(C, &GA)); |
| 162 | |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 163 | // Loop over the module, adding globals which are obviously necessary. |
Peter Collingbourne | 6d88fde | 2016-06-22 20:29:42 +0000 | [diff] [blame] | 164 | for (GlobalObject &GO : M.global_objects()) { |
| 165 | Changed |= RemoveUnusedGlobalValue(GO); |
| 166 | // Functions with external linkage are needed if they have a body. |
Chris Lattner | c8dfbbb | 2003-09-20 19:00:50 +0000 | [diff] [blame] | 167 | // Externally visible & appending globals are needed, if they have an |
| 168 | // initializer. |
Peter Collingbourne | 6d88fde | 2016-06-22 20:29:42 +0000 | [diff] [blame] | 169 | if (!GO.isDeclaration() && !GO.hasAvailableExternallyLinkage()) |
| 170 | if (!GO.isDiscardableIfUnused()) |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 171 | MarkLive(GO); |
| 172 | |
| 173 | UpdateGVDependencies(GO); |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 174 | } |
| 175 | |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 176 | // Compute direct dependencies of aliases. |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 177 | for (GlobalAlias &GA : M.aliases()) { |
| 178 | Changed |= RemoveUnusedGlobalValue(GA); |
Duncan Sands | f5dbbae | 2009-01-05 20:37:33 +0000 | [diff] [blame] | 179 | // Externally visible aliases are needed. |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 180 | if (!GA.isDiscardableIfUnused()) |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 181 | MarkLive(GA); |
| 182 | |
| 183 | UpdateGVDependencies(GA); |
David Majnemer | dad0a64 | 2014-06-27 18:19:56 +0000 | [diff] [blame] | 184 | } |
| 185 | |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 186 | // Compute direct dependencies of ifuncs. |
David Majnemer | 9554949 | 2016-05-04 00:20:48 +0000 | [diff] [blame] | 187 | for (GlobalIFunc &GIF : M.ifuncs()) { |
| 188 | Changed |= RemoveUnusedGlobalValue(GIF); |
| 189 | // Externally visible ifuncs are needed. |
| 190 | if (!GIF.isDiscardableIfUnused()) |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 191 | MarkLive(GIF); |
| 192 | |
| 193 | UpdateGVDependencies(GIF); |
| 194 | } |
| 195 | |
| 196 | // Propagate liveness from collected Global Values through the computed |
| 197 | // dependencies. |
| 198 | SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(), |
| 199 | AliveGlobals.end()}; |
| 200 | while (!NewLiveGVs.empty()) { |
| 201 | GlobalValue *LGV = NewLiveGVs.pop_back_val(); |
| 202 | for (auto &&GVD : make_range(GVDependencies.equal_range(LGV))) |
| 203 | MarkLive(*GVD.second, &NewLiveGVs); |
David Majnemer | 9554949 | 2016-05-04 00:20:48 +0000 | [diff] [blame] | 204 | } |
| 205 | |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 206 | // Now that all globals which are needed are in the AliveGlobals set, we loop |
| 207 | // through the program, deleting those which are not alive. |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 208 | // |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 209 | |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 210 | // The first pass is to drop initializers of global variables which are dead. |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 211 | std::vector<GlobalVariable *> DeadGlobalVars; // Keep track of dead globals |
| 212 | for (GlobalVariable &GV : M.globals()) |
| 213 | if (!AliveGlobals.count(&GV)) { |
| 214 | DeadGlobalVars.push_back(&GV); // Keep track of dead globals |
| 215 | if (GV.hasInitializer()) { |
| 216 | Constant *Init = GV.getInitializer(); |
| 217 | GV.setInitializer(nullptr); |
Bruno Cardoso Lopes | e2a1fa3 | 2014-08-25 17:51:14 +0000 | [diff] [blame] | 218 | if (isSafeToDestroyConstant(Init)) |
| 219 | Init->destroyConstant(); |
| 220 | } |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 221 | } |
| 222 | |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 223 | // The second pass drops the bodies of functions which are dead... |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 224 | std::vector<Function *> DeadFunctions; |
| 225 | for (Function &F : M) |
| 226 | if (!AliveGlobals.count(&F)) { |
| 227 | DeadFunctions.push_back(&F); // Keep track of dead globals |
Chandler Carruth | 6acdca7 | 2017-01-24 12:55:57 +0000 | [diff] [blame] | 228 | if (!F.isDeclaration()) |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 229 | F.deleteBody(); |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 230 | } |
| 231 | |
Duncan Sands | bf3ba5a | 2009-02-17 23:05:26 +0000 | [diff] [blame] | 232 | // The third pass drops targets of aliases which are dead... |
| 233 | std::vector<GlobalAlias*> DeadAliases; |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 234 | for (GlobalAlias &GA : M.aliases()) |
| 235 | if (!AliveGlobals.count(&GA)) { |
| 236 | DeadAliases.push_back(&GA); |
| 237 | GA.setAliasee(nullptr); |
Duncan Sands | bf3ba5a | 2009-02-17 23:05:26 +0000 | [diff] [blame] | 238 | } |
| 239 | |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 240 | // The fourth pass drops targets of ifuncs which are dead... |
David Majnemer | 9554949 | 2016-05-04 00:20:48 +0000 | [diff] [blame] | 241 | std::vector<GlobalIFunc*> DeadIFuncs; |
| 242 | for (GlobalIFunc &GIF : M.ifuncs()) |
| 243 | if (!AliveGlobals.count(&GIF)) { |
| 244 | DeadIFuncs.push_back(&GIF); |
| 245 | GIF.setResolver(nullptr); |
| 246 | } |
| 247 | |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 248 | // Now that all interferences have been dropped, delete the actual objects |
| 249 | // themselves. |
| 250 | auto EraseUnusedGlobalValue = [&](GlobalValue *GV) { |
| 251 | RemoveUnusedGlobalValue(*GV); |
| 252 | GV->eraseFromParent(); |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 253 | Changed = true; |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 254 | }; |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 255 | |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 256 | NumFunctions += DeadFunctions.size(); |
| 257 | for (Function *F : DeadFunctions) |
| 258 | EraseUnusedGlobalValue(F); |
Misha Brukman | b1c9317 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 259 | |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 260 | NumVariables += DeadGlobalVars.size(); |
| 261 | for (GlobalVariable *GV : DeadGlobalVars) |
| 262 | EraseUnusedGlobalValue(GV); |
Duncan Sands | f5dbbae | 2009-01-05 20:37:33 +0000 | [diff] [blame] | 263 | |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 264 | NumAliases += DeadAliases.size(); |
| 265 | for (GlobalAlias *GA : DeadAliases) |
| 266 | EraseUnusedGlobalValue(GA); |
| 267 | |
Peter Collingbourne | 4f3b2df | 2016-10-25 02:57:27 +0000 | [diff] [blame] | 268 | NumIFuncs += DeadIFuncs.size(); |
Peter Collingbourne | 7695cb6 | 2016-10-25 01:58:26 +0000 | [diff] [blame] | 269 | for (GlobalIFunc *GIF : DeadIFuncs) |
| 270 | EraseUnusedGlobalValue(GIF); |
David Majnemer | 9554949 | 2016-05-04 00:20:48 +0000 | [diff] [blame] | 271 | |
Chris Lattner | ec6d7a6 | 2003-09-16 19:27:31 +0000 | [diff] [blame] | 272 | // Make sure that all memory is released |
| 273 | AliveGlobals.clear(); |
Mehdi Amini | 888dee4 | 2017-01-27 19:48:57 +0000 | [diff] [blame] | 274 | ConstantDependenciesCache.clear(); |
| 275 | GVDependencies.clear(); |
Peter Collingbourne | 0dbc708 | 2015-03-19 18:23:29 +0000 | [diff] [blame] | 276 | ComdatMembers.clear(); |
Devang Patel | c5aa8c6 | 2009-08-11 06:31:57 +0000 | [diff] [blame] | 277 | |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 278 | if (Changed) |
| 279 | return PreservedAnalyses::none(); |
| 280 | return PreservedAnalyses::all(); |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 281 | } |
| 282 | |
Reid Spencer | 5f68159 | 2004-07-18 00:25:04 +0000 | [diff] [blame] | 283 | // RemoveUnusedGlobalValue - Loop over all of the uses of the specified |
Chris Lattner | 8f3acc6 | 2002-08-18 01:28:30 +0000 | [diff] [blame] | 284 | // GlobalValue, looking for the constant pointer ref that may be pointing to it. |
| 285 | // If found, check to see if the constant pointer ref is safe to destroy, and if |
| 286 | // so, nuke it. This will reduce the reference count on the global value, which |
| 287 | // might make it deader. |
| 288 | // |
Davide Italiano | 66228c4 | 2016-05-03 19:39:15 +0000 | [diff] [blame] | 289 | bool GlobalDCEPass::RemoveUnusedGlobalValue(GlobalValue &GV) { |
Yaron Keren | 3d49f6d | 2015-07-18 19:57:34 +0000 | [diff] [blame] | 290 | if (GV.use_empty()) |
| 291 | return false; |
Chris Lattner | 9238d78 | 2004-07-18 07:22:58 +0000 | [diff] [blame] | 292 | GV.removeDeadConstantUsers(); |
| 293 | return GV.use_empty(); |
| 294 | } |