From 233728e8c324580a173ecb131109dee228e87303 Mon Sep 17 00:00:00 2001 From: Devang Patel Date: Tue, 18 Nov 2008 21:34:39 +0000 Subject: [PATCH] Add new helper pass that strips all symbol names except debugging information. This pass makes it easier to test wheter debugging info. influences optimization passes or not. llvm-svn: 59552 --- include/llvm/LinkAllPasses.h | 1 + include/llvm/Transforms/IPO.h | 7 +++ lib/Transforms/IPO/StripSymbols.cpp | 79 +++++++++++++++++++---------- 3 files changed, 59 insertions(+), 28 deletions(-) diff --git a/include/llvm/LinkAllPasses.h b/include/llvm/LinkAllPasses.h index 0d9ba26aa14..f6d1bf70b6b 100644 --- a/include/llvm/LinkAllPasses.h +++ b/include/llvm/LinkAllPasses.h @@ -102,6 +102,7 @@ namespace { (void) llvm::createSimplifyHalfPowrLibCallsPass(); (void) llvm::createSingleLoopExtractorPass(); (void) llvm::createStripSymbolsPass(); + (void) llvm::createStripNonDebugSymbolsPass(); (void) llvm::createStripDeadPrototypesPass(); (void) llvm::createTailCallEliminationPass(); (void) llvm::createTailDuplicationPass(); diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index 887614074c5..0d4e33af123 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -33,6 +33,13 @@ class GlobalValue; // ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); +//===----------------------------------------------------------------------===// +// +// These functions removes symbols from functions and modules. +// Only debugging information is not removed. +// +ModulePass *createStripNonDebugSymbolsPass(); + //===----------------------------------------------------------------------===// /// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics /// to invoke/unwind instructions. This should really be part of the C/C++ diff --git a/lib/Transforms/IPO/StripSymbols.cpp b/lib/Transforms/IPO/StripSymbols.cpp index d25e7580883..c5101c95b82 100644 --- a/lib/Transforms/IPO/StripSymbols.cpp +++ b/lib/Transforms/IPO/StripSymbols.cpp @@ -40,13 +40,18 @@ namespace { explicit StripSymbols(bool ODI = false) : ModulePass(&ID), OnlyDebugInfo(ODI) {} - /// StripSymbolNames - Strip symbol names. - bool StripSymbolNames(Module &M); + virtual bool runOnModule(Module &M); - // StripDebugInfo - 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. - bool StripDebugInfo(Module &M); + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } + }; + + class VISIBILITY_HIDDEN StripNonDebugSymbols : public ModulePass { + public: + static char ID; // Pass identification, replacement for typeid + explicit StripNonDebugSymbols() + : ModulePass(&ID) {} virtual bool runOnModule(Module &M); @@ -64,6 +69,14 @@ ModulePass *llvm::createStripSymbolsPass(bool OnlyDebugInfo) { return new StripSymbols(OnlyDebugInfo); } +char StripNonDebugSymbols::ID = 0; +static RegisterPass +Y("strip-nondebug", "Strip all symbols, except dbg symbols, from a module"); + +ModulePass *llvm::createStripNonDebugSymbolsPass() { + return new StripNonDebugSymbols(); +} + /// OnlyUsedBy - Return true if V is only used by Usr. static bool OnlyUsedBy(Value *V, Value *Usr) { for(Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) { @@ -96,28 +109,26 @@ static void RemoveDeadConstant(Constant *C) { // Strip the symbol table of its names. // -static void StripSymtab(ValueSymbolTable &ST) { +static void StripSymtab(ValueSymbolTable &ST, bool PreserveDbgInfo) { for (ValueSymbolTable::iterator VI = ST.begin(), VE = ST.end(); VI != VE; ) { Value *V = VI->getValue(); ++VI; if (!isa(V) || cast(V)->hasInternalLinkage()) { - // Set name to "", removing from symbol table! - V->setName(""); + if (!PreserveDbgInfo || strncmp(V->getNameStart(), "llvm.dbg", 8)) + // Set name to "", removing from symbol table! + V->setName(""); } } } -bool StripSymbols::runOnModule(Module &M) { - bool Changed = false; - Changed |= StripDebugInfo(M); - Changed |= StripSymbolNames(M); - return Changed; -} - // 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++); +static void StripTypeSymtab(TypeSymbolTable &ST, bool PreserveDbgInfo) { + for (TypeSymbolTable::iterator TI = ST.begin(), E = ST.end(); TI != E; ) { + if (PreserveDbgInfo && strncmp(TI->first.c_str(), "llvm.dbg", 8) == 0) + ++TI; + else + ST.remove(TI++); + } } /// Find values that are marked as llvm.used. @@ -143,10 +154,7 @@ void findUsedValues(Module &M, } /// StripSymbolNames - Strip symbol names. -bool StripSymbols::StripSymbolNames(Module &M) { - - if (OnlyDebugInfo) - return false; +bool StripSymbolNames(Module &M, bool PreserveDbgInfo) { SmallPtrSet llvmUsedValues; findUsedValues(M, llvmUsedValues); @@ -154,17 +162,19 @@ bool StripSymbols::StripSymbolNames(Module &M) { for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) { if (I->hasInternalLinkage() && llvmUsedValues.count(I) == 0) - I->setName(""); // Internal symbols can't participate in linkage + if (!PreserveDbgInfo || strncmp(I->getNameStart(), "llvm.dbg", 8)) + I->setName(""); // Internal symbols can't participate in linkage } for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { if (I->hasInternalLinkage() && llvmUsedValues.count(I) == 0) - I->setName(""); // Internal symbols can't participate in linkage - StripSymtab(I->getValueSymbolTable()); + if (!PreserveDbgInfo || strncmp(I->getNameStart(), "llvm.dbg", 8)) + I->setName(""); // Internal symbols can't participate in linkage + StripSymtab(I->getValueSymbolTable(), PreserveDbgInfo); } // Remove all names from types. - StripTypeSymtab(M.getTypeSymbolTable()); + StripTypeSymtab(M.getTypeSymbolTable(), PreserveDbgInfo); return true; } @@ -172,7 +182,7 @@ bool StripSymbols::StripSymbolNames(Module &M) { // StripDebugInfo - 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. -bool StripSymbols::StripDebugInfo(Module &M) { +bool StripDebugInfo(Module &M) { Function *FuncStart = M.getFunction("llvm.dbg.func.start"); Function *StopPoint = M.getFunction("llvm.dbg.stoppoint"); @@ -302,3 +312,16 @@ bool StripSymbols::StripDebugInfo(Module &M) { return true; } + +bool StripSymbols::runOnModule(Module &M) { + bool Changed = false; + Changed |= StripDebugInfo(M); + if (!OnlyDebugInfo) + Changed |= StripSymbolNames(M, false); + return Changed; +} + +bool StripNonDebugSymbols::runOnModule(Module &M) { + return StripSymbolNames(M, true); +} +