//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
-// This file implements stripping symbols out of symbol tables.
+// The StripSymbols transformation implements code stripping. Specifically, it
+// can delete:
+//
+// * names for virtual registers
+// * symbols for internal globals and functions
+// * debug information
//
-// Specifically, this allows you to strip all of the symbols out of:
-// * All functions in a module
-// * All non-essential symbols in a module (all function symbols + all module
-// scope symbols)
-// * Debug information.
-//
-// Notice that:
-// * This pass makes code much less readable, so it should only be used in
-// situations where the 'strip' utility would be used (such as reducing
-// code size, and making it harder to reverse engineer code).
+// Note that this transformation makes code much less readable, so it should
+// only be used in situations where the 'strip' utility would be used, such as
+// reducing code size or making it harder to reverse engineer code.
//
//===----------------------------------------------------------------------===//
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
#include "llvm/TypeSymbolTable.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
namespace {
- class StripSymbols : public ModulePass {
+ class VISIBILITY_HIDDEN StripSymbols : public ModulePass {
bool OnlyDebugInfo;
public:
- StripSymbols(bool ODI = false) : OnlyDebugInfo(ODI) {}
+ static char ID; // Pass identification, replacement for typeid
+ explicit StripSymbols(bool ODI = false)
+ : ModulePass((intptr_t)&ID), OnlyDebugInfo(ODI) {}
virtual bool runOnModule(Module &M);
AU.setPreservesAll();
}
};
+
+ char StripSymbols::ID = 0;
RegisterPass<StripSymbols> X("strip", "Strip all symbols from a module");
}
}
}
+// Strip the symbol table of its names.
+//
+static void StripSymtab(ValueSymbolTable &ST) {
+ for (ValueSymbolTable::iterator VI = ST.begin(), VE = ST.end(); VI != VE; ) {
+ Value *V = VI->getValue();
+ ++VI;
+ if (!isa<GlobalValue>(V) || cast<GlobalValue>(V)->hasInternalLinkage()) {
+ // Set name to "", removing from symbol table!
+ V->setName("");
+ }
+ }
+}
+
+// Strip the symbol table of its names.
+static void StripTypeSymtab(TypeSymbolTable &ST) {
+ for (TypeSymbolTable::iterator TI = ST.begin(), E = ST.end(); TI != E; )
+ ST.remove(TI++);
+}
+
+
+
bool StripSymbols::runOnModule(Module &M) {
// If we're not just stripping debug info, strip all symbols from the
// functions and the names from any internal globals.
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
if (I->hasInternalLinkage())
I->setName(""); // Internal symbols can't participate in linkage
- I->getValueSymbolTable().strip();
+ StripSymtab(I->getValueSymbolTable());
}
// Remove all names from types.
- M.getTypeSymbolTable().strip();
+ StripTypeSymtab(M.getTypeSymbolTable());
}
// Strip debug info in the module if it exists. To do this, we remove
// llvm.dbg.func.start, llvm.dbg.stoppoint, and llvm.dbg.region.end calls, and
// any globals they point to if now dead.
- Function *FuncStart = M.getNamedFunction("llvm.dbg.func.start");
- Function *StopPoint = M.getNamedFunction("llvm.dbg.stoppoint");
- Function *RegionStart = M.getNamedFunction("llvm.dbg.region.start");
- Function *RegionEnd = M.getNamedFunction("llvm.dbg.region.end");
- Function *Declare = M.getNamedFunction("llvm.dbg.declare");
+ Function *FuncStart = M.getFunction("llvm.dbg.func.start");
+ Function *StopPoint = M.getFunction("llvm.dbg.stoppoint");
+ Function *RegionStart = M.getFunction("llvm.dbg.region.start");
+ Function *RegionEnd = M.getFunction("llvm.dbg.region.end");
+ Function *Declare = M.getFunction("llvm.dbg.declare");
if (!FuncStart && !StopPoint && !RegionStart && !RegionEnd && !Declare)
return true;