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/Constants.h"
25#include "llvm/DebugInfo.h"
26#include "llvm/DerivedTypes.h"
27#include "llvm/Instructions.h"
28#include "llvm/Module.h"
29#include "llvm/Pass.h"
30#include "llvm/TypeFinder.h"
31#include "llvm/ValueSymbolTable.h"
32#include "llvm/Transforms/Utils/Local.h"
33#include "llvm/ADT/DenseMap.h"
34#include "llvm/ADT/SmallPtrSet.h"
35using namespace llvm;
36
37namespace {
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    virtual bool runOnModule(Module &M);
48
49    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
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    virtual bool runOnModule(Module &M);
63
64    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
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    virtual bool runOnModule(Module &M);
78
79    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
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    virtual bool runOnModule(Module &M);
93
94    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
95      AU.setPreservesAll();
96    }
97  };
98}
99
100char StripSymbols::ID = 0;
101INITIALIZE_PASS(StripSymbols, "strip",
102                "Strip all symbols from a module", false, false)
103
104ModulePass *llvm::createStripSymbolsPass(bool OnlyDebugInfo) {
105  return new StripSymbols(OnlyDebugInfo);
106}
107
108char StripNonDebugSymbols::ID = 0;
109INITIALIZE_PASS(StripNonDebugSymbols, "strip-nondebug",
110                "Strip all symbols, except dbg symbols, from a module",
111                false, false)
112
113ModulePass *llvm::createStripNonDebugSymbolsPass() {
114  return new StripNonDebugSymbols();
115}
116
117char StripDebugDeclare::ID = 0;
118INITIALIZE_PASS(StripDebugDeclare, "strip-debug-declare",
119                "Strip all llvm.dbg.declare intrinsics", false, false)
120
121ModulePass *llvm::createStripDebugDeclarePass() {
122  return new StripDebugDeclare();
123}
124
125char StripDeadDebugInfo::ID = 0;
126INITIALIZE_PASS(StripDeadDebugInfo, "strip-dead-debug-info",
127                "Strip debug info for unused symbols", false, false)
128
129ModulePass *llvm::createStripDeadDebugInfoPass() {
130  return new StripDeadDebugInfo();
131}
132
133/// OnlyUsedBy - Return true if V is only used by Usr.
134static bool OnlyUsedBy(Value *V, Value *Usr) {
135  for(Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
136    User *U = *I;
137    if (U != Usr)
138      return false;
139  }
140  return true;
141}
142
143static void RemoveDeadConstant(Constant *C) {
144  assert(C->use_empty() && "Constant is not dead!");
145  SmallPtrSet<Constant*, 4> Operands;
146  for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
147    if (OnlyUsedBy(C->getOperand(i), C))
148      Operands.insert(cast<Constant>(C->getOperand(i)));
149  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
150    if (!GV->hasLocalLinkage()) return;   // Don't delete non static globals.
151    GV->eraseFromParent();
152  }
153  else if (!isa<Function>(C))
154    if (isa<CompositeType>(C->getType()))
155      C->destroyConstant();
156
157  // If the constant referenced anything, see if we can delete it as well.
158  for (SmallPtrSet<Constant*, 4>::iterator OI = Operands.begin(),
159         OE = Operands.end(); OI != OE; ++OI)
160    RemoveDeadConstant(*OI);
161}
162
163// Strip the symbol table of its names.
164//
165static void StripSymtab(ValueSymbolTable &ST, bool PreserveDbgInfo) {
166  for (ValueSymbolTable::iterator VI = ST.begin(), VE = ST.end(); VI != VE; ) {
167    Value *V = VI->getValue();
168    ++VI;
169    if (!isa<GlobalValue>(V) || cast<GlobalValue>(V)->hasLocalLinkage()) {
170      if (!PreserveDbgInfo || !V->getName().startswith("llvm.dbg"))
171        // Set name to "", removing from symbol table!
172        V->setName("");
173    }
174  }
175}
176
177// Strip any named types of their names.
178static void StripTypeNames(Module &M, bool PreserveDbgInfo) {
179  TypeFinder StructTypes;
180  StructTypes.run(M, false);
181
182  for (unsigned i = 0, e = StructTypes.size(); i != e; ++i) {
183    StructType *STy = StructTypes[i];
184    if (STy->isLiteral() || STy->getName().empty()) continue;
185
186    if (PreserveDbgInfo && STy->getName().startswith("llvm.dbg"))
187      continue;
188
189    STy->setName("");
190  }
191}
192
193/// Find values that are marked as llvm.used.
194static void findUsedValues(GlobalVariable *LLVMUsed,
195                           SmallPtrSet<const GlobalValue*, 8> &UsedValues) {
196  if (LLVMUsed == 0) return;
197  UsedValues.insert(LLVMUsed);
198
199  ConstantArray *Inits = dyn_cast<ConstantArray>(LLVMUsed->getInitializer());
200  if (Inits == 0) return;
201
202  for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i)
203    if (GlobalValue *GV =
204          dyn_cast<GlobalValue>(Inits->getOperand(i)->stripPointerCasts()))
205      UsedValues.insert(GV);
206}
207
208/// StripSymbolNames - Strip symbol names.
209static bool StripSymbolNames(Module &M, bool PreserveDbgInfo) {
210
211  SmallPtrSet<const GlobalValue*, 8> llvmUsedValues;
212  findUsedValues(M.getGlobalVariable("llvm.used"), llvmUsedValues);
213  findUsedValues(M.getGlobalVariable("llvm.compiler.used"), llvmUsedValues);
214
215  for (Module::global_iterator I = M.global_begin(), E = M.global_end();
216       I != E; ++I) {
217    if (I->hasLocalLinkage() && llvmUsedValues.count(I) == 0)
218      if (!PreserveDbgInfo || !I->getName().startswith("llvm.dbg"))
219        I->setName("");     // Internal symbols can't participate in linkage
220  }
221
222  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
223    if (I->hasLocalLinkage() && llvmUsedValues.count(I) == 0)
224      if (!PreserveDbgInfo || !I->getName().startswith("llvm.dbg"))
225        I->setName("");     // Internal symbols can't participate in linkage
226    StripSymtab(I->getValueSymbolTable(), PreserveDbgInfo);
227  }
228
229  // Remove all names from types.
230  StripTypeNames(M, PreserveDbgInfo);
231
232  return true;
233}
234
235// StripDebugInfo - Strip debug info in the module if it exists.
236// To do this, we remove llvm.dbg.func.start, llvm.dbg.stoppoint, and
237// llvm.dbg.region.end calls, and any globals they point to if now dead.
238static bool StripDebugInfo(Module &M) {
239
240  bool Changed = false;
241
242  // Remove all of the calls to the debugger intrinsics, and remove them from
243  // the module.
244  if (Function *Declare = M.getFunction("llvm.dbg.declare")) {
245    while (!Declare->use_empty()) {
246      CallInst *CI = cast<CallInst>(Declare->use_back());
247      CI->eraseFromParent();
248    }
249    Declare->eraseFromParent();
250    Changed = true;
251  }
252
253  if (Function *DbgVal = M.getFunction("llvm.dbg.value")) {
254    while (!DbgVal->use_empty()) {
255      CallInst *CI = cast<CallInst>(DbgVal->use_back());
256      CI->eraseFromParent();
257    }
258    DbgVal->eraseFromParent();
259    Changed = true;
260  }
261
262  for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
263         NME = M.named_metadata_end(); NMI != NME;) {
264    NamedMDNode *NMD = NMI;
265    ++NMI;
266    if (NMD->getName().startswith("llvm.dbg.")) {
267      NMD->eraseFromParent();
268      Changed = true;
269    }
270  }
271
272  for (Module::iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI)
273    for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE;
274         ++FI)
275      for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE;
276           ++BI) {
277        if (!BI->getDebugLoc().isUnknown()) {
278          Changed = true;
279          BI->setDebugLoc(DebugLoc());
280        }
281      }
282
283  return Changed;
284}
285
286bool StripSymbols::runOnModule(Module &M) {
287  bool Changed = false;
288  Changed |= StripDebugInfo(M);
289  if (!OnlyDebugInfo)
290    Changed |= StripSymbolNames(M, false);
291  return Changed;
292}
293
294bool StripNonDebugSymbols::runOnModule(Module &M) {
295  return StripSymbolNames(M, true);
296}
297
298bool StripDebugDeclare::runOnModule(Module &M) {
299
300  Function *Declare = M.getFunction("llvm.dbg.declare");
301  std::vector<Constant*> DeadConstants;
302
303  if (Declare) {
304    while (!Declare->use_empty()) {
305      CallInst *CI = cast<CallInst>(Declare->use_back());
306      Value *Arg1 = CI->getArgOperand(0);
307      Value *Arg2 = CI->getArgOperand(1);
308      assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
309      CI->eraseFromParent();
310      if (Arg1->use_empty()) {
311        if (Constant *C = dyn_cast<Constant>(Arg1))
312          DeadConstants.push_back(C);
313        else
314          RecursivelyDeleteTriviallyDeadInstructions(Arg1);
315      }
316      if (Arg2->use_empty())
317        if (Constant *C = dyn_cast<Constant>(Arg2))
318          DeadConstants.push_back(C);
319    }
320    Declare->eraseFromParent();
321  }
322
323  while (!DeadConstants.empty()) {
324    Constant *C = DeadConstants.back();
325    DeadConstants.pop_back();
326    if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
327      if (GV->hasLocalLinkage())
328        RemoveDeadConstant(GV);
329    } else
330      RemoveDeadConstant(C);
331  }
332
333  return true;
334}
335
336/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
337/// printer to not emit usual symbol prefix before the symbol name is used then
338/// return linkage name after skipping this special LLVM prefix.
339static StringRef getRealLinkageName(StringRef LinkageName) {
340  char One = '\1';
341  if (LinkageName.startswith(StringRef(&One, 1)))
342    return LinkageName.substr(1);
343  return LinkageName;
344}
345
346bool StripDeadDebugInfo::runOnModule(Module &M) {
347  bool Changed = false;
348
349  // Debugging infomration is encoded in llvm IR using metadata. This is designed
350  // such a way that debug info for symbols preserved even if symbols are
351  // optimized away by the optimizer. This special pass removes debug info for
352  // such symbols.
353
354  // llvm.dbg.gv keeps track of debug info for global variables.
355  if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv")) {
356    SmallVector<MDNode *, 8> MDs;
357    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
358      if (DIGlobalVariable(NMD->getOperand(i)).Verify())
359        MDs.push_back(NMD->getOperand(i));
360      else
361        Changed = true;
362    NMD->eraseFromParent();
363    NMD = NULL;
364
365    for (SmallVector<MDNode *, 8>::iterator I = MDs.begin(),
366           E = MDs.end(); I != E; ++I) {
367      GlobalVariable *GV = DIGlobalVariable(*I).getGlobal();
368      if (GV && M.getGlobalVariable(GV->getName(), true)) {
369        if (!NMD)
370          NMD = M.getOrInsertNamedMetadata("llvm.dbg.gv");
371        NMD->addOperand(*I);
372      }
373      else
374        Changed = true;
375    }
376  }
377
378  // llvm.dbg.sp keeps track of debug info for subprograms.
379  if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) {
380    SmallVector<MDNode *, 8> MDs;
381    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
382      if (DISubprogram(NMD->getOperand(i)).Verify())
383        MDs.push_back(NMD->getOperand(i));
384      else
385        Changed = true;
386    NMD->eraseFromParent();
387    NMD = NULL;
388
389    for (SmallVector<MDNode *, 8>::iterator I = MDs.begin(),
390           E = MDs.end(); I != E; ++I) {
391      bool FnIsLive = false;
392      if (Function *F = DISubprogram(*I).getFunction())
393        if (M.getFunction(F->getName()))
394          FnIsLive = true;
395      if (FnIsLive) {
396          if (!NMD)
397            NMD = M.getOrInsertNamedMetadata("llvm.dbg.sp");
398          NMD->addOperand(*I);
399      } else {
400        // Remove llvm.dbg.lv.fnname named mdnode which may have been used
401        // to hold debug info for dead function's local variables.
402        StringRef FName = DISubprogram(*I).getLinkageName();
403        if (FName.empty())
404          FName = DISubprogram(*I).getName();
405        if (NamedMDNode *LVNMD =
406            M.getNamedMetadata(Twine("llvm.dbg.lv.",
407                                     getRealLinkageName(FName))))
408          LVNMD->eraseFromParent();
409      }
410    }
411  }
412
413  return Changed;
414}
415