1 //===- StripSymbols.cpp - Strip symbols and debug info from a module ------===// 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 // The StripSymbols transformation implements code stripping. Specifically, it 11 // can delete: 12 // 13 // * names for virtual registers 14 // * symbols for internal globals and functions 15 // * debug information 16 // 17 // Note that this transformation makes code much less readable, so it should 18 // only be used in situations where the 'strip' utility would be used, such as 19 // reducing code size or making it harder to reverse engineer code. 20 // 21 //===----------------------------------------------------------------------===// 22 23 #include "llvm/Transforms/IPO.h" 24 #include "llvm/ADT/DenseMap.h" 25 #include "llvm/ADT/SmallPtrSet.h" 26 #include "llvm/IR/Constants.h" 27 #include "llvm/IR/DebugInfo.h" 28 #include "llvm/IR/DerivedTypes.h" 29 #include "llvm/IR/Instructions.h" 30 #include "llvm/IR/Module.h" 31 #include "llvm/IR/TypeFinder.h" 32 #include "llvm/IR/ValueSymbolTable.h" 33 #include "llvm/Pass.h" 34 #include "llvm/Transforms/Utils/Local.h" 35 using namespace llvm; 36 37 namespace { 38 class StripSymbols : public ModulePass { 39 bool OnlyDebugInfo; 40 public: 41 static char ID; // Pass identification, replacement for typeid 42 explicit StripSymbols(bool ODI = false) 43 : ModulePass(ID), OnlyDebugInfo(ODI) { 44 initializeStripSymbolsPass(*PassRegistry::getPassRegistry()); 45 } 46 47 bool runOnModule(Module &M) override; 48 49 void getAnalysisUsage(AnalysisUsage &AU) const override { 50 AU.setPreservesAll(); 51 } 52 }; 53 54 class StripNonDebugSymbols : public ModulePass { 55 public: 56 static char ID; // Pass identification, replacement for typeid 57 explicit StripNonDebugSymbols() 58 : ModulePass(ID) { 59 initializeStripNonDebugSymbolsPass(*PassRegistry::getPassRegistry()); 60 } 61 62 bool runOnModule(Module &M) override; 63 64 void getAnalysisUsage(AnalysisUsage &AU) const override { 65 AU.setPreservesAll(); 66 } 67 }; 68 69 class StripDebugDeclare : public ModulePass { 70 public: 71 static char ID; // Pass identification, replacement for typeid 72 explicit StripDebugDeclare() 73 : ModulePass(ID) { 74 initializeStripDebugDeclarePass(*PassRegistry::getPassRegistry()); 75 } 76 77 bool runOnModule(Module &M) override; 78 79 void getAnalysisUsage(AnalysisUsage &AU) const override { 80 AU.setPreservesAll(); 81 } 82 }; 83 84 class StripDeadDebugInfo : public ModulePass { 85 public: 86 static char ID; // Pass identification, replacement for typeid 87 explicit StripDeadDebugInfo() 88 : ModulePass(ID) { 89 initializeStripDeadDebugInfoPass(*PassRegistry::getPassRegistry()); 90 } 91 92 bool runOnModule(Module &M) override; 93 94 void getAnalysisUsage(AnalysisUsage &AU) const override { 95 AU.setPreservesAll(); 96 } 97 }; 98 } 99 100 char StripSymbols::ID = 0; 101 INITIALIZE_PASS(StripSymbols, "strip", 102 "Strip all symbols from a module", false, false) 103 104 ModulePass *llvm::createStripSymbolsPass(bool OnlyDebugInfo) { 105 return new StripSymbols(OnlyDebugInfo); 106 } 107 108 char StripNonDebugSymbols::ID = 0; 109 INITIALIZE_PASS(StripNonDebugSymbols, "strip-nondebug", 110 "Strip all symbols, except dbg symbols, from a module", 111 false, false) 112 113 ModulePass *llvm::createStripNonDebugSymbolsPass() { 114 return new StripNonDebugSymbols(); 115 } 116 117 char StripDebugDeclare::ID = 0; 118 INITIALIZE_PASS(StripDebugDeclare, "strip-debug-declare", 119 "Strip all llvm.dbg.declare intrinsics", false, false) 120 121 ModulePass *llvm::createStripDebugDeclarePass() { 122 return new StripDebugDeclare(); 123 } 124 125 char StripDeadDebugInfo::ID = 0; 126 INITIALIZE_PASS(StripDeadDebugInfo, "strip-dead-debug-info", 127 "Strip debug info for unused symbols", false, false) 128 129 ModulePass *llvm::createStripDeadDebugInfoPass() { 130 return new StripDeadDebugInfo(); 131 } 132 133 /// OnlyUsedBy - Return true if V is only used by Usr. 134 static bool OnlyUsedBy(Value *V, Value *Usr) { 135 for (User *U : V->users()) 136 if (U != Usr) 137 return false; 138 139 return true; 140 } 141 142 static void RemoveDeadConstant(Constant *C) { 143 assert(C->use_empty() && "Constant is not dead!"); 144 SmallPtrSet<Constant*, 4> Operands; 145 for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) 146 if (OnlyUsedBy(C->getOperand(i), C)) 147 Operands.insert(cast<Constant>(C->getOperand(i))); 148 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) { 149 if (!GV->hasLocalLinkage()) return; // Don't delete non-static globals. 150 GV->eraseFromParent(); 151 } 152 else if (!isa<Function>(C)) 153 if (isa<CompositeType>(C->getType())) 154 C->destroyConstant(); 155 156 // If the constant referenced anything, see if we can delete it as well. 157 for (SmallPtrSet<Constant*, 4>::iterator OI = Operands.begin(), 158 OE = Operands.end(); OI != OE; ++OI) 159 RemoveDeadConstant(*OI); 160 } 161 162 // Strip the symbol table of its names. 163 // 164 static void StripSymtab(ValueSymbolTable &ST, bool PreserveDbgInfo) { 165 for (ValueSymbolTable::iterator VI = ST.begin(), VE = ST.end(); VI != VE; ) { 166 Value *V = VI->getValue(); 167 ++VI; 168 if (!isa<GlobalValue>(V) || cast<GlobalValue>(V)->hasLocalLinkage()) { 169 if (!PreserveDbgInfo || !V->getName().startswith("llvm.dbg")) 170 // Set name to "", removing from symbol table! 171 V->setName(""); 172 } 173 } 174 } 175 176 // Strip any named types of their names. 177 static void StripTypeNames(Module &M, bool PreserveDbgInfo) { 178 TypeFinder StructTypes; 179 StructTypes.run(M, false); 180 181 for (unsigned i = 0, e = StructTypes.size(); i != e; ++i) { 182 StructType *STy = StructTypes[i]; 183 if (STy->isLiteral() || STy->getName().empty()) continue; 184 185 if (PreserveDbgInfo && STy->getName().startswith("llvm.dbg")) 186 continue; 187 188 STy->setName(""); 189 } 190 } 191 192 /// Find values that are marked as llvm.used. 193 static void findUsedValues(GlobalVariable *LLVMUsed, 194 SmallPtrSet<const GlobalValue*, 8> &UsedValues) { 195 if (!LLVMUsed) return; 196 UsedValues.insert(LLVMUsed); 197 198 ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer()); 199 200 for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i) 201 if (GlobalValue *GV = 202 dyn_cast<GlobalValue>(Inits->getOperand(i)->stripPointerCasts())) 203 UsedValues.insert(GV); 204 } 205 206 /// StripSymbolNames - Strip symbol names. 207 static bool StripSymbolNames(Module &M, bool PreserveDbgInfo) { 208 209 SmallPtrSet<const GlobalValue*, 8> llvmUsedValues; 210 findUsedValues(M.getGlobalVariable("llvm.used"), llvmUsedValues); 211 findUsedValues(M.getGlobalVariable("llvm.compiler.used"), llvmUsedValues); 212 213 for (Module::global_iterator I = M.global_begin(), E = M.global_end(); 214 I != E; ++I) { 215 if (I->hasLocalLinkage() && llvmUsedValues.count(I) == 0) 216 if (!PreserveDbgInfo || !I->getName().startswith("llvm.dbg")) 217 I->setName(""); // Internal symbols can't participate in linkage 218 } 219 220 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { 221 if (I->hasLocalLinkage() && llvmUsedValues.count(I) == 0) 222 if (!PreserveDbgInfo || !I->getName().startswith("llvm.dbg")) 223 I->setName(""); // Internal symbols can't participate in linkage 224 StripSymtab(I->getValueSymbolTable(), PreserveDbgInfo); 225 } 226 227 // Remove all names from types. 228 StripTypeNames(M, PreserveDbgInfo); 229 230 return true; 231 } 232 233 bool StripSymbols::runOnModule(Module &M) { 234 bool Changed = false; 235 Changed |= StripDebugInfo(M); 236 if (!OnlyDebugInfo) 237 Changed |= StripSymbolNames(M, false); 238 return Changed; 239 } 240 241 bool StripNonDebugSymbols::runOnModule(Module &M) { 242 return StripSymbolNames(M, true); 243 } 244 245 bool StripDebugDeclare::runOnModule(Module &M) { 246 247 Function *Declare = M.getFunction("llvm.dbg.declare"); 248 std::vector<Constant*> DeadConstants; 249 250 if (Declare) { 251 while (!Declare->use_empty()) { 252 CallInst *CI = cast<CallInst>(Declare->user_back()); 253 Value *Arg1 = CI->getArgOperand(0); 254 Value *Arg2 = CI->getArgOperand(1); 255 assert(CI->use_empty() && "llvm.dbg intrinsic should have void result"); 256 CI->eraseFromParent(); 257 if (Arg1->use_empty()) { 258 if (Constant *C = dyn_cast<Constant>(Arg1)) 259 DeadConstants.push_back(C); 260 else 261 RecursivelyDeleteTriviallyDeadInstructions(Arg1); 262 } 263 if (Arg2->use_empty()) 264 if (Constant *C = dyn_cast<Constant>(Arg2)) 265 DeadConstants.push_back(C); 266 } 267 Declare->eraseFromParent(); 268 } 269 270 while (!DeadConstants.empty()) { 271 Constant *C = DeadConstants.back(); 272 DeadConstants.pop_back(); 273 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) { 274 if (GV->hasLocalLinkage()) 275 RemoveDeadConstant(GV); 276 } else 277 RemoveDeadConstant(C); 278 } 279 280 return true; 281 } 282 283 /// Remove any debug info for global variables/functions in the given module for 284 /// which said global variable/function no longer exists (i.e. is null). 285 /// 286 /// Debugging information is encoded in llvm IR using metadata. This is designed 287 /// such a way that debug info for symbols preserved even if symbols are 288 /// optimized away by the optimizer. This special pass removes debug info for 289 /// such symbols. 290 bool StripDeadDebugInfo::runOnModule(Module &M) { 291 bool Changed = false; 292 293 LLVMContext &C = M.getContext(); 294 295 // Find all debug info in F. This is actually overkill in terms of what we 296 // want to do, but we want to try and be as resilient as possible in the face 297 // of potential debug info changes by using the formal interfaces given to us 298 // as much as possible. 299 DebugInfoFinder F; 300 F.processModule(M); 301 302 // For each compile unit, find the live set of global variables/functions and 303 // replace the current list of potentially dead global variables/functions 304 // with the live list. 305 SmallVector<Value *, 64> LiveGlobalVariables; 306 SmallVector<Value *, 64> LiveSubprograms; 307 DenseSet<const MDNode *> VisitedSet; 308 309 for (DICompileUnit DIC : F.compile_units()) { 310 assert(DIC.Verify() && "DIC must verify as a DICompileUnit."); 311 312 // Create our live subprogram list. 313 DIArray SPs = DIC.getSubprograms(); 314 bool SubprogramChange = false; 315 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) { 316 DISubprogram DISP(SPs.getElement(i)); 317 assert(DISP.Verify() && "DISP must verify as a DISubprogram."); 318 319 // Make sure we visit each subprogram only once. 320 if (!VisitedSet.insert(DISP).second) 321 continue; 322 323 // If the function referenced by DISP is not null, the function is live. 324 if (DISP.getFunction()) 325 LiveSubprograms.push_back(DISP); 326 else 327 SubprogramChange = true; 328 } 329 330 // Create our live global variable list. 331 DIArray GVs = DIC.getGlobalVariables(); 332 bool GlobalVariableChange = false; 333 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { 334 DIGlobalVariable DIG(GVs.getElement(i)); 335 assert(DIG.Verify() && "DIG must verify as DIGlobalVariable."); 336 337 // Make sure we only visit each global variable only once. 338 if (!VisitedSet.insert(DIG).second) 339 continue; 340 341 // If the global variable referenced by DIG is not null, the global 342 // variable is live. 343 if (DIG.getGlobal()) 344 LiveGlobalVariables.push_back(DIG); 345 else 346 GlobalVariableChange = true; 347 } 348 349 // If we found dead subprograms or global variables, replace the current 350 // subprogram list/global variable list with our new live subprogram/global 351 // variable list. 352 if (SubprogramChange) { 353 // Make sure that 9 is still the index of the subprograms. This is to make 354 // sure that an assert is hit if the location of the subprogram array 355 // changes. This is just to make sure that this is updated if such an 356 // event occurs. 357 assert(DIC->getNumOperands() >= 10 && 358 SPs == DIC->getOperand(9) && 359 "DICompileUnits is expected to store Subprograms in operand " 360 "9."); 361 DIC->replaceOperandWith(9, MDNode::get(C, LiveSubprograms)); 362 Changed = true; 363 } 364 365 if (GlobalVariableChange) { 366 // Make sure that 10 is still the index of global variables. This is to 367 // make sure that an assert is hit if the location of the subprogram array 368 // changes. This is just to make sure that this index is updated if such 369 // an event occurs. 370 assert(DIC->getNumOperands() >= 11 && 371 GVs == DIC->getOperand(10) && 372 "DICompileUnits is expected to store Global Variables in operand " 373 "10."); 374 DIC->replaceOperandWith(10, MDNode::get(C, LiveGlobalVariables)); 375 Changed = true; 376 } 377 378 // Reset lists for the next iteration. 379 LiveSubprograms.clear(); 380 LiveGlobalVariables.clear(); 381 } 382 383 return Changed; 384 } 385