lib/Transforms/IPO/StripSymbols.cpp

   1 //===- StripSymbols.cpp - Strip symbols and debug info from a module ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements stripping symbols out of symbol tables.
  11 //
  12 // Specifically, this allows you to strip all of the symbols out of:
  13 //   * All functions in a module
  14 //   * All non-essential symbols in a module (all function symbols + all module
  15 //     scope symbols)
  16 //   * Debug information.
  17 //
  18 // Notice that:
  19 //   * This pass makes code much less readable, so it should only be used in
  20 //     situations where the 'strip' utility would be used (such as reducing
  21 //     code size, and making it harder to reverse engineer code).
  22 //
  23 //===----------------------------------------------------------------------===//
  24
  25 #include "llvm/Transforms/IPO.h"
  26 #include "llvm/Constants.h"
  27 #include "llvm/DerivedTypes.h"
  28 #include "llvm/Instructions.h"
  29 #include "llvm/Module.h"
  30 #include "llvm/Pass.h"
  31 #include "llvm/SymbolTable.h"
  32 using namespace llvm;
  33
  34 namespace {
  35   class StripSymbols : public ModulePass {
  36     bool OnlyDebugInfo;
  37   public:
  38     StripSymbols(bool ODI = false) : OnlyDebugInfo(ODI) {}
  39
  40     virtual bool runOnModule(Module &M);
  41
  42     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  43       AU.setPreservesAll();
  44     }
  45   };
  46   RegisterOpt<StripSymbols> X("strip", "Strip all symbols from a module");
  47 }
  48
  49 ModulePass *llvm::createStripSymbolsPass(bool OnlyDebugInfo) {
  50   return new StripSymbols(OnlyDebugInfo);
  51 }
  52
  53 static void RemoveDeadConstant(Constant *C) {
  54   assert(C->use_empty() && "Constant is not dead!");
  55   std::vector<Constant*> Operands;
  56   for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
  57     if (isa<DerivedType>(C->getOperand(i)->getType()) &&
  58         C->getOperand(i)->hasOneUse())
  59       Operands.push_back(C->getOperand(i));
  60   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
  61     if (!GV->hasInternalLinkage()) return;   // Don't delete non static globals.
  62     GV->eraseFromParent();
  63   }
  64   else if (!isa<Function>(C))
  65     C->destroyConstant();
  66
  67   // If the constant referenced anything, see if we can delete it as well.
  68   while (!Operands.empty()) {
  69     RemoveDeadConstant(Operands.back());
  70     Operands.pop_back();
  71   }
  72 }
  73
  74 bool StripSymbols::runOnModule(Module &M) {
  75   // If we're not just stripping debug info, strip all symbols from the
  76   // functions and the names from any internal globals.
  77   if (!OnlyDebugInfo) {
  78     for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
  79       if (I->hasInternalLinkage())
  80         I->setName("");     // Internal symbols can't participate in linkage
  81
  82     for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
  83       if (I->hasInternalLinkage())
  84         I->setName("");     // Internal symbols can't participate in linkage
  85       I->getSymbolTable().strip();
  86     }
  87
  88     // Remove all names from types.
  89     SymbolTable &SymTab = M.getSymbolTable();
  90     while (SymTab.type_begin() != SymTab.type_end())
  91       SymTab.remove(SymTab.type_begin());
  92   }
  93
  94   // Strip debug info in the module if it exists.  To do this, we remove
  95   // llvm.dbg.func.start, llvm.dbg.stoppoint, and llvm.dbg.region.end calls, and
  96   // any globals they point to if now dead.
  97   Function *FuncStart = M.getNamedFunction("llvm.dbg.func.start");
  98   Function *StopPoint = M.getNamedFunction("llvm.dbg.stoppoint");
  99   Function *RegionStart = M.getNamedFunction("llvm.dbg.region.start");
 100   Function *RegionEnd = M.getNamedFunction("llvm.dbg.region.end");
 101   Function *Declare = M.getNamedFunction("llvm.dbg.declare");
 102   if (!FuncStart && !StopPoint && !RegionStart && !RegionEnd && !Declare)
 103     return true;
 104
 105   std::vector<GlobalVariable*> DeadGlobals;
 106
 107   // Remove all of the calls to the debugger intrinsics, and remove them from
 108   // the module.
 109   if (FuncStart) {
 110     while (!FuncStart->use_empty()) {
 111       CallInst *CI = cast<CallInst>(FuncStart->use_back());
 112       Value *Arg = CI->getOperand(1);
 113       assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
 114       CI->eraseFromParent();
 115       if (Arg->use_empty())
 116         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Arg))
 117           DeadGlobals.push_back(GV);
 118     }
 119     FuncStart->eraseFromParent();
 120   }
 121   if (StopPoint) {
 122     while (!StopPoint->use_empty()) {
 123       CallInst *CI = cast<CallInst>(StopPoint->use_back());
 124       Value *Arg = CI->getOperand(3);
 125       assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
 126       CI->eraseFromParent();
 127       if (Arg->use_empty())
 128         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Arg))
 129           DeadGlobals.push_back(GV);
 130     }
 131     StopPoint->eraseFromParent();
 132   }
 133   if (RegionStart) {
 134     while (!RegionStart->use_empty()) {
 135       CallInst *CI = cast<CallInst>(RegionStart->use_back());
 136       Value *Arg = CI->getOperand(1);
 137       assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
 138       CI->eraseFromParent();
 139       if (Arg->use_empty())
 140         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Arg))
 141           DeadGlobals.push_back(GV);
 142     }
 143     RegionStart->eraseFromParent();
 144   }
 145   if (RegionEnd) {
 146     while (!RegionEnd->use_empty()) {
 147       CallInst *CI = cast<CallInst>(RegionEnd->use_back());
 148       Value *Arg = CI->getOperand(1);
 149       assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
 150       CI->eraseFromParent();
 151       if (Arg->use_empty())
 152         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Arg))
 153           DeadGlobals.push_back(GV);
 154     }
 155     RegionEnd->eraseFromParent();
 156   }
 157   if (Declare) {
 158     while (!Declare->use_empty()) {
 159       CallInst *CI = cast<CallInst>(Declare->use_back());
 160       Value *Arg = CI->getOperand(2);
 161       assert(CI->use_empty() && "llvm.dbg intrinsic should have void result");
 162       CI->eraseFromParent();
 163       if (Arg->use_empty())
 164         if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Arg))
 165           DeadGlobals.push_back(GV);
 166     }
 167     Declare->eraseFromParent();
 168   }
 169
 170   // Finally, delete any internal globals that were only used by the debugger
 171   // intrinsics.
 172   while (!DeadGlobals.empty()) {
 173     GlobalVariable *GV = DeadGlobals.back();
 174     DeadGlobals.pop_back();
 175     if (GV->hasInternalLinkage())
 176       RemoveDeadConstant(GV);
 177   }
 178
 179   return true;
 180 }