X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FIPO%2FInternalize.cpp;h=7950163f757dd6a8866f49ce4c1da5d4de3712d0;hb=9ba744b0890819cb602281779dfacc4efd54db70;hp=2eec95ff618cde9993299fbe64fbd421b2d50fb8;hpb=7f8897f22e88271cfa114998a4d6088e7c8e8e11;p=oota-llvm.git diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp index 2eec95ff618..7950163f757 100644 --- a/lib/Transforms/IPO/Internalize.cpp +++ b/lib/Transforms/IPO/Internalize.cpp @@ -2,70 +2,89 @@ // // 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 pass loops over all of the functions in the input module, looking for a -// main function. If a main function is found, all other functions and all -// global variables with initializers are marked as internal. +// This pass loops over all of the functions and variables in the input module. +// If the function or variable is not in the list of external names given to +// the pass it is marked as internal. +// +// This transformation would not be legal in a regular compilation, but it gets +// extra information from the linker about what is safe. +// +// For example: Internalizing a function with external linkage. Only if we are +// told it is only used from within this module, it is safe to do it. // //===----------------------------------------------------------------------===// #include "llvm/Transforms/IPO.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Analysis/CallGraph.h" +#include "llvm/IR/Module.h" #include "llvm/Pass.h" -#include "llvm/Module.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" -#include "llvm/ADT/Statistic.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Transforms/Utils/GlobalStatus.h" +#include "llvm/Transforms/Utils/ModuleUtils.h" #include -#include #include using namespace llvm; -namespace { - Statistic<> NumFunctions("internalize", "Number of functions internalized"); - Statistic<> NumGlobals ("internalize", "Number of global vars internalized"); +#define DEBUG_TYPE "internalize" - // APIFile - A file which contains a list of symbols that should not be marked - // external. - cl::opt - APIFile("internalize-public-api-file", cl::value_desc("filename"), - cl::desc("A file containing list of symbol names to preserve")); +STATISTIC(NumAliases , "Number of aliases internalized"); +STATISTIC(NumFunctions, "Number of functions internalized"); +STATISTIC(NumGlobals , "Number of global vars internalized"); - // APIList - A list of symbols that should not be marked internal. - cl::list - APIList("internalize-public-api-list", cl::value_desc("list"), - cl::desc("A list of symbol names to preserve"), - cl::CommaSeparated); +// APIFile - A file which contains a list of symbols that should not be marked +// external. +static cl::opt +APIFile("internalize-public-api-file", cl::value_desc("filename"), + cl::desc("A file containing list of symbol names to preserve")); +// APIList - A list of symbols that should not be marked internal. +static cl::list +APIList("internalize-public-api-list", cl::value_desc("list"), + cl::desc("A list of symbol names to preserve"), + cl::CommaSeparated); + +namespace { class InternalizePass : public ModulePass { std::set ExternalNames; - bool DontInternalize; public: - InternalizePass(bool InternalizeEverything = true); - InternalizePass(const std::vector & exportList); + static char ID; // Pass identification, replacement for typeid + explicit InternalizePass(); + explicit InternalizePass(ArrayRef ExportList); void LoadFile(const char *Filename); - virtual bool runOnModule(Module &M); + bool runOnModule(Module &M) override; + + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesCFG(); + AU.addPreserved(); + } }; - RegisterPass X("internalize", "Internalize Global Symbols"); } // end anonymous namespace -InternalizePass::InternalizePass(bool InternalizeEverything) - : DontInternalize(false){ - if (!APIFile.empty()) // If a filename is specified, use it +char InternalizePass::ID = 0; +INITIALIZE_PASS(InternalizePass, "internalize", + "Internalize Global Symbols", false, false) + +InternalizePass::InternalizePass() : ModulePass(ID) { + initializeInternalizePassPass(*PassRegistry::getPassRegistry()); + 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; + ExternalNames.insert(APIList.begin(), APIList.end()); } -InternalizePass::InternalizePass(const std::vector&exportList) { - for(std::vector::const_iterator itr = exportList.begin(); - itr != exportList.end(); itr++) { +InternalizePass::InternalizePass(ArrayRef ExportList) + : ModulePass(ID) { + initializeInternalizePassPass(*PassRegistry::getPassRegistry()); + for(ArrayRef::const_iterator itr = ExportList.begin(); + itr != ExportList.end(); itr++) { ExternalNames.insert(*itr); } } @@ -74,9 +93,9 @@ 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... + errs() << "WARNING: Internalize couldn't load file '" << Filename + << "'! Continuing as if it's empty.\n"; + return; // Just continue as if the file were empty } while (In) { std::string Symbol; @@ -86,80 +105,120 @@ void InternalizePass::LoadFile(const char *Filename) { } } +static bool shouldInternalize(const GlobalValue &GV, + const std::set &ExternalNames) { + // Function must be defined here + if (GV.isDeclaration()) + return false; + + // Available externally is really just a "declaration with a body". + if (GV.hasAvailableExternallyLinkage()) + return false; + + // Assume that dllexported symbols are referenced elsewhere + if (GV.hasDLLExportStorageClass()) + return false; + + // Already has internal linkage + if (GV.hasLocalLinkage()) + return false; + + // Marked to keep external? + if (ExternalNames.count(GV.getName())) + return false; + + return true; +} + 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()); - } - + CallGraphWrapperPass *CGPass = getAnalysisIfAvailable(); + CallGraph *CG = CGPass ? &CGPass->getCallGraph() : nullptr; + CallGraphNode *ExternalNode = CG ? CG->getExternalCallingNode() : nullptr; 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"); - } - + + SmallPtrSet Used; + collectUsedGlobalVariables(M, Used, false); + + // We must assume that globals in llvm.used have a reference that not even + // the linker can see, so we don't internalize them. + // For llvm.compiler.used the situation is a bit fuzzy. The assembler and + // linker can drop those symbols. If this pass is running as part of LTO, + // one might think that it could just drop llvm.compiler.used. The problem + // is that even in LTO llvm doesn't see every reference. For example, + // we don't see references from function local inline assembly. To be + // conservative, we internalize symbols in llvm.compiler.used, but we + // keep llvm.compiler.used so that the symbol is not deleted by llvm. + for (GlobalValue *V : Used) { + ExternalNames.insert(V->getName()); + } + + // Mark all functions not in the api as internal. + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { + if (!shouldInternalize(*I, ExternalNames)) + continue; + + I->setVisibility(GlobalValue::DefaultVisibility); + I->setLinkage(GlobalValue::InternalLinkage); + + if (ExternalNode) + // Remove a callgraph edge from the external node to this function. + ExternalNode->removeOneAbstractEdgeTo((*CG)[I]); + + Changed = true; + ++NumFunctions; + DEBUG(dbgs() << "Internalizing func " << I->getName() << "\n"); + } + // Never internalize the llvm.used symbol. It is used to implement // attribute((used)). + // FIXME: Shouldn't this just filter on llvm.metadata section?? ExternalNames.insert("llvm.used"); - - // Never internalize anchors used by the debugger, else the debugger won't - // find them. (see MachineDebugInfo.) - ExternalNames.insert("llvm.dbg.compile_units"); - ExternalNames.insert("llvm.dbg.global_variables"); - ExternalNames.insert("llvm.dbg.subprograms"); - - // Mark all global variables with initializers as internal as well. + ExternalNames.insert("llvm.compiler.used"); + + // Never internalize anchors used by the machine module info, else the info + // won't find them. (see MachineModuleInfo.) + ExternalNames.insert("llvm.global_ctors"); + ExternalNames.insert("llvm.global_dtors"); + ExternalNames.insert("llvm.global.annotations"); + + // Never internalize symbols code-gen inserts. + // FIXME: We should probably add this (and the __stack_chk_guard) via some + // type of call-back in CodeGen. + ExternalNames.insert("__stack_chk_fail"); + ExternalNames.insert("__stack_chk_guard"); + + // Mark all global variables with initializers that are not in the api 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 (I->hasAppendingLinkage() && (I->getName() == "llvm.global_ctors" || - I->getName() == "llvm.global_dtors")) { - // If the global ctors/dtors list has no uses, do not internalize it, as - // there is no __main in this program, so the asmprinter should handle - // it. - if (I->use_empty()) continue; - - // Otherwise, also mark the list constant, as we know that it will not - // be mutated any longer, and the makes simple IPO xforms automatically - // better. - I->setConstant(true); - } - - I->setLinkage(GlobalValue::InternalLinkage); - Changed = true; - ++NumGlobals; - DEBUG(std::cerr << "Internalized gvar " << I->getName() << "\n"); - } - + I != E; ++I) { + if (!shouldInternalize(*I, ExternalNames)) + continue; + + I->setVisibility(GlobalValue::DefaultVisibility); + I->setLinkage(GlobalValue::InternalLinkage); + Changed = true; + ++NumGlobals; + DEBUG(dbgs() << "Internalized gvar " << I->getName() << "\n"); + } + + // Mark all aliases that are not in the api as internal as well. + for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); + I != E; ++I) { + if (!shouldInternalize(*I, ExternalNames)) + continue; + + I->setVisibility(GlobalValue::DefaultVisibility); + I->setLinkage(GlobalValue::InternalLinkage); + Changed = true; + ++NumAliases; + DEBUG(dbgs() << "Internalized alias " << I->getName() << "\n"); + } + return Changed; } -ModulePass *llvm::createInternalizePass(bool InternalizeEverything) { - return new InternalizePass(InternalizeEverything); -} +ModulePass *llvm::createInternalizePass() { return new InternalizePass(); } -ModulePass *llvm::createInternalizePass(const std::vector &el) { - return new InternalizePass(el); +ModulePass *llvm::createInternalizePass(ArrayRef ExportList) { + return new InternalizePass(ExportList); }