Changes in directory llvm/lib/Transforms/IPO:
Internalize.cpp updated: 1.27 -> 1.28 --- Log message: Pull inline methods out of the pass class definition to make it easier to read the code. Do not internalize debugger anchors. --- Diffs of the changes: (+88 -78) Internalize.cpp | 166 +++++++++++++++++++++++++++++--------------------------- 1 files changed, 88 insertions(+), 78 deletions(-) Index: llvm/lib/Transforms/IPO/Internalize.cpp diff -u llvm/lib/Transforms/IPO/Internalize.cpp:1.27 llvm/lib/Transforms/IPO/Internalize.cpp:1.28 --- llvm/lib/Transforms/IPO/Internalize.cpp:1.27 Sun Dec 4 23:07:38 2005 +++ llvm/lib/Transforms/IPO/Internalize.cpp Tue Jan 3 13:13:17 2006 @@ -43,89 +43,99 @@ std::set<std::string> ExternalNames; bool DontInternalize; public: - InternalizePass(bool InternalizeEverything = true) : DontInternalize(false){ - if (!APIFile.empty()) // If a filename is specified, use it - LoadFile(APIFile.c_str()); - else if (!APIList.empty()) // Else, if a list is specified, use it. - ExternalNames.insert(APIList.begin(), APIList.end()); - else if (!InternalizeEverything) - // Finally, if we're allowed to, internalize all but main. - DontInternalize = true; - } + InternalizePass(bool InternalizeEverything = true); + void LoadFile(const char *Filename); + virtual bool runOnModule(Module &M); + }; + RegisterOpt<InternalizePass> X("internalize", "Internalize Global Symbols"); +} // end anonymous namespace - void LoadFile(const char *Filename) { - // Load the APIFile... - std::ifstream In(Filename); - if (!In.good()) { - std::cerr << "WARNING: Internalize couldn't load file '" << Filename - << "'!\n"; - return; // Do not internalize anything... - } - while (In) { - std::string Symbol; - In >> Symbol; - if (!Symbol.empty()) - ExternalNames.insert(Symbol); - } - } +InternalizePass::InternalizePass(bool InternalizeEverything) + : DontInternalize(false){ + if (!APIFile.empty()) // If a filename is specified, use it + LoadFile(APIFile.c_str()); + else if (!APIList.empty()) // Else, if a list is specified, use it. + ExternalNames.insert(APIList.begin(), APIList.end()); + else if (!InternalizeEverything) + // Finally, if we're allowed to, internalize all but main. + DontInternalize = true; +} - virtual bool runOnModule(Module &M) { - if (DontInternalize) return false; +void InternalizePass::LoadFile(const char *Filename) { + // Load the APIFile... + std::ifstream In(Filename); + if (!In.good()) { + std::cerr << "WARNING: Internalize couldn't load file '" << Filename + << "'!\n"; + return; // Do not internalize anything... + } + while (In) { + std::string Symbol; + In >> Symbol; + if (!Symbol.empty()) + ExternalNames.insert(Symbol); + } +} + +bool InternalizePass::runOnModule(Module &M) { + if (DontInternalize) return false; + + // If no list or file of symbols was specified, check to see if there is a + // "main" symbol defined in the module. If so, use it, otherwise do not + // internalize the module, it must be a library or something. + // + if (ExternalNames.empty()) { + Function *MainFunc = M.getMainFunction(); + if (MainFunc == 0 || MainFunc->isExternal()) + return false; // No main found, must be a library... + + // Preserve main, internalize all else. + ExternalNames.insert(MainFunc->getName()); + } + + bool Changed = false; + + // Found a main function, mark all functions not named main as internal. + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + if (!I->isExternal() && // Function must be defined here + !I->hasInternalLinkage() && // Can't already have internal linkage + !ExternalNames.count(I->getName())) {// Not marked to keep external? + I->setLinkage(GlobalValue::InternalLinkage); + Changed = true; + ++NumFunctions; + DEBUG(std::cerr << "Internalizing func " << I->getName() << "\n"); + } + + // Never internalize the llvm.used symbol. It is used to implement + // attribute((used)). + ExternalNames.insert("llvm.used"); + + // Never internalize anchors used by the debugger, else the debugger won't + // find them. + ExternalNames.insert("llvm.dbg.translation_units"); + ExternalNames.insert("llvm.dbg.globals"); - // If no list or file of symbols was specified, check to see if there is a - // "main" symbol defined in the module. If so, use it, otherwise do not - // internalize the module, it must be a library or something. + // Mark all global variables with initializers as internal as well. + for (Module::global_iterator I = M.global_begin(), E = M.global_end(); + I != E; ++I) + if (!I->isExternal() && !I->hasInternalLinkage() && + !ExternalNames.count(I->getName())) { + // Special case handling of the global ctor and dtor list. When we + // internalize it, we mark it constant, which allows elimination of + // the list if it's empty. // - if (ExternalNames.empty()) { - Function *MainFunc = M.getMainFunction(); - if (MainFunc == 0 || MainFunc->isExternal()) - return false; // No main found, must be a library... - - // Preserve main, internalize all else. - ExternalNames.insert(MainFunc->getName()); - } - - bool Changed = false; - - // Found a main function, mark all functions not named main as internal. - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - if (!I->isExternal() && // Function must be defined here - !I->hasInternalLinkage() && // Can't already have internal linkage - !ExternalNames.count(I->getName())) {// Not marked to keep external? - I->setLinkage(GlobalValue::InternalLinkage); - Changed = true; - ++NumFunctions; - DEBUG(std::cerr << "Internalizing func " << I->getName() << "\n"); - } - - // Mark all global variables with initializers as internal as well... - for (Module::global_iterator I = M.global_begin(), E = M.global_end(); - I != E; ++I) - if (!I->isExternal() && !I->hasInternalLinkage() && - !ExternalNames.count(I->getName()) && - // *never* internalize the llvm.used symbol, used to implement - // attribute((used)). - I->getName() != "llvm.used") { - // Special case handling of the global ctor and dtor list. When we - // internalize it, we mark it constant, which allows elimination of - // the list if it's empty. - // - if (I->hasAppendingLinkage() && (I->getName() == "llvm.global_ctors"|| - I->getName() == "llvm.global_dtors")) - I->setConstant(true); - - I->setLinkage(GlobalValue::InternalLinkage); - Changed = true; - ++NumGlobals; - DEBUG(std::cerr << "Internalizing gvar " << I->getName() << "\n"); - } - - return Changed; + if (I->hasAppendingLinkage() && (I->getName() == "llvm.global_ctors" || + I->getName() == "llvm.global_dtors")) + I->setConstant(true); + + I->setLinkage(GlobalValue::InternalLinkage); + Changed = true; + ++NumGlobals; + DEBUG(std::cerr << "Internalizing gvar " << I->getName() << "\n"); } - }; - - RegisterOpt<InternalizePass> X("internalize", "Internalize Global Symbols"); -} // end anonymous namespace + + return Changed; +} ModulePass *llvm::createInternalizePass(bool InternalizeEverything) { return new InternalizePass(InternalizeEverything); _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits