//
// 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"
+#include "llvm/ADT/SmallPtrSet.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.
if (!OnlyDebugInfo) {
+ SmallPtrSet<const GlobalValue*, 8> llvmUsedValues;
+ if (GlobalVariable *LLVMUsed = M.getGlobalVariable("llvm.used")) {
+ llvmUsedValues.insert(LLVMUsed);
+ // Collect values that are preserved as per explicit request.
+ // llvm.used is used to list these values.
+ if (ConstantArray *Inits =
+ dyn_cast<ConstantArray>(LLVMUsed->getInitializer())) {
+ for (unsigned i = 0, e = Inits->getNumOperands(); i != e; ++i) {
+ if (GlobalValue *GV = dyn_cast<GlobalValue>(Inits->getOperand(i)))
+ llvmUsedValues.insert(GV);
+ else if (ConstantExpr *CE =
+ dyn_cast<ConstantExpr>(Inits->getOperand(i)))
+ if (CE->getOpcode() == Instruction::BitCast)
+ if (GlobalValue *GV = dyn_cast<GlobalValue>(CE->getOperand(0)))
+ llvmUsedValues.insert(GV);
+ }
+ }
+ }
+
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
- I != E; ++I)
- if (I->hasInternalLinkage())
+ I != E; ++I) {
+ if (I->hasInternalLinkage() && llvmUsedValues.count(I) == 0)
I->setName(""); // Internal symbols can't participate in linkage
+ }
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
- if (I->hasInternalLinkage())
+ if (I->hasInternalLinkage() && llvmUsedValues.count(I) == 0)
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;