1 //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 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. 15 // 16 //===----------------------------------------------------------------------===// 17 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" 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 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())) 82 return false; 83 ReturnInst &RI = cast<ReturnInst>(Entry.front()); 84 return RI.getReturnValue() == nullptr; 85 } 86 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(); 93 Deps.insert(Parent); 94 } else if (auto *GV = dyn_cast<GlobalValue>(V)) { 95 Deps.insert(GV); 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()); 102 } else { 103 SmallPtrSetImpl<GlobalValue *> &LocalDeps = ConstantDependenciesCache[CE]; 104 for (User *CEUser : CE->users()) 105 ComputeDependencies(CEUser, LocalDeps); 106 Deps.insert(LocalDeps.begin(), LocalDeps.end()); 107 } 108 } 109 } 110 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); 118 } 119 } 120 121 /// Mark Global value as Live 122 void GlobalDCEPass::MarkLive(GlobalValue &GV, 123 SmallVectorImpl<GlobalValue *> *Updates) { 124 auto const Ret = AliveGlobals.insert(&GV); 125 if (!Ret.second) 126 return; 127 128 if (Updates) 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. 134 } 135 } 136 137 PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) { 138 bool Changed = false; 139 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. 147 148 // Remove empty functions from the global ctors list. 149 Changed |= optimizeGlobalCtorsList(M, isEmptyFunction); 150 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)); 161 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 167 // initializer. 168 if (!GO.isDeclaration() && !GO.hasAvailableExternallyLinkage()) 169 if (!GO.isDiscardableIfUnused()) 170 MarkLive(GO); 171 172 UpdateGVDependencies(GO); 173 } 174 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()) 180 MarkLive(GA); 181 182 UpdateGVDependencies(GA); 183 } 184 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()) 190 MarkLive(GIF); 191 192 UpdateGVDependencies(GIF); 193 } 194 195 // Propagate liveness from collected Global Values through the computed 196 // dependencies. 197 SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(), 198 AliveGlobals.end()}; 199 while (!NewLiveGVs.empty()) { 200 GlobalValue *LGV = NewLiveGVs.pop_back_val(); 201 for (auto *GVD : GVDependencies[LGV]) 202 MarkLive(*GVD, &NewLiveGVs); 203 } 204 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. 207 // 208 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(); 219 } 220 } 221 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()) 228 F.deleteBody(); 229 } 230 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); 237 } 238 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); 245 } 246 247 // Now that all interferences have been dropped, delete the actual objects 248 // themselves. 249 auto EraseUnusedGlobalValue = [&](GlobalValue *GV) { 250 RemoveUnusedGlobalValue(*GV); 251 GV->eraseFromParent(); 252 Changed = true; 253 }; 254 255 NumFunctions += DeadFunctions.size(); 256 for (Function *F : DeadFunctions) 257 EraseUnusedGlobalValue(F); 258 259 NumVariables += DeadGlobalVars.size(); 260 for (GlobalVariable *GV : DeadGlobalVars) 261 EraseUnusedGlobalValue(GV); 262 263 NumAliases += DeadAliases.size(); 264 for (GlobalAlias *GA : DeadAliases) 265 EraseUnusedGlobalValue(GA); 266 267 NumIFuncs += DeadIFuncs.size(); 268 for (GlobalIFunc *GIF : DeadIFuncs) 269 EraseUnusedGlobalValue(GIF); 270 271 // Make sure that all memory is released 272 AliveGlobals.clear(); 273 ConstantDependenciesCache.clear(); 274 GVDependencies.clear(); 275 ComdatMembers.clear(); 276 277 if (Changed) 278 return PreservedAnalyses::none(); 279 return PreservedAnalyses::all(); 280 } 281 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. 287 // 288 bool GlobalDCEPass::RemoveUnusedGlobalValue(GlobalValue &GV) { 289 if (GV.use_empty()) 290 return false; 291 GV.removeDeadConstantUsers(); 292 return GV.use_empty(); 293 } 294