Internalize.cpp revision 5de97242323586a5e4399a26f69831bb7edc2156
1//===-- Internalize.cpp - Mark functions internal -------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This pass loops over all of the functions in the input module, looking for a 11// main function. If a main function is found, all other functions and all 12// global variables with initializers are marked as internal. 13// 14//===----------------------------------------------------------------------===// 15 16#define DEBUG_TYPE "internalize" 17#include "llvm/Analysis/CallGraph.h" 18#include "llvm/Transforms/IPO.h" 19#include "llvm/Pass.h" 20#include "llvm/Module.h" 21#include "llvm/Support/CommandLine.h" 22#include "llvm/Support/Compiler.h" 23#include "llvm/Support/Debug.h" 24#include "llvm/ADT/Statistic.h" 25#include <fstream> 26#include <set> 27using namespace llvm; 28 29STATISTIC(NumFunctions, "Number of functions internalized"); 30STATISTIC(NumGlobals , "Number of global vars internalized"); 31 32// APIFile - A file which contains a list of symbols that should not be marked 33// external. 34static cl::opt<std::string> 35APIFile("internalize-public-api-file", cl::value_desc("filename"), 36 cl::desc("A file containing list of symbol names to preserve")); 37 38// APIList - A list of symbols that should not be marked internal. 39static cl::list<std::string> 40APIList("internalize-public-api-list", cl::value_desc("list"), 41 cl::desc("A list of symbol names to preserve"), 42 cl::CommaSeparated); 43 44namespace { 45 class VISIBILITY_HIDDEN InternalizePass : public ModulePass { 46 std::set<std::string> ExternalNames; 47 /// If no api symbols were specified and a main function is defined, 48 /// assume the main function is the only API 49 bool AllButMain; 50 public: 51 static char ID; // Pass identification, replacement for typeid 52 explicit InternalizePass(bool AllButMain = true); 53 explicit InternalizePass(const std::vector <const char *>& exportList); 54 void LoadFile(const char *Filename); 55 virtual bool runOnModule(Module &M); 56 57 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 58 AU.setPreservesCFG(); 59 AU.addPreserved<CallGraph>(); 60 } 61 }; 62} // end anonymous namespace 63 64char InternalizePass::ID = 0; 65static RegisterPass<InternalizePass> 66X("internalize", "Internalize Global Symbols"); 67 68InternalizePass::InternalizePass(bool AllButMain) 69 : ModulePass(&ID), AllButMain(AllButMain){ 70 if (!APIFile.empty()) // If a filename is specified, use it. 71 LoadFile(APIFile.c_str()); 72 if (!APIList.empty()) // If a list is specified, use it as well. 73 ExternalNames.insert(APIList.begin(), APIList.end()); 74} 75 76InternalizePass::InternalizePass(const std::vector<const char *>&exportList) 77 : ModulePass(&ID), AllButMain(false){ 78 for(std::vector<const char *>::const_iterator itr = exportList.begin(); 79 itr != exportList.end(); itr++) { 80 ExternalNames.insert(*itr); 81 } 82} 83 84void InternalizePass::LoadFile(const char *Filename) { 85 // Load the APIFile... 86 std::ifstream In(Filename); 87 if (!In.good()) { 88 cerr << "WARNING: Internalize couldn't load file '" << Filename 89 << "'! Continuing as if it's empty.\n"; 90 return; // Just continue as if the file were empty 91 } 92 while (In) { 93 std::string Symbol; 94 In >> Symbol; 95 if (!Symbol.empty()) 96 ExternalNames.insert(Symbol); 97 } 98} 99 100bool InternalizePass::runOnModule(Module &M) { 101 if (ExternalNames.empty()) { 102 // Return if we're not in 'all but main' mode and have no external api 103 if (!AllButMain) 104 return false; 105 // If no list or file of symbols was specified, check to see if there is a 106 // "main" symbol defined in the module. If so, use it, otherwise do not 107 // internalize the module, it must be a library or something. 108 // 109 Function *MainFunc = M.getFunction("main"); 110 if (MainFunc == 0 || MainFunc->isDeclaration()) 111 return false; // No main found, must be a library... 112 113 // Preserve main, internalize all else. 114 ExternalNames.insert(MainFunc->getName()); 115 } 116 117 bool Changed = false; 118 119 // Mark all functions not in the api as internal. 120 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 121 if (!I->isDeclaration() && // Function must be defined here 122 !I->hasInternalLinkage() && // Can't already have internal linkage 123 !ExternalNames.count(I->getName())) {// Not marked to keep external? 124 I->setLinkage(GlobalValue::InternalLinkage); 125 Changed = true; 126 ++NumFunctions; 127 DOUT << "Internalizing func " << I->getName() << "\n"; 128 } 129 130 // Never internalize the llvm.used symbol. It is used to implement 131 // attribute((used)). 132 ExternalNames.insert("llvm.used"); 133 134 // Never internalize anchors used by the machine module info, else the info 135 // won't find them. (see MachineModuleInfo.) 136 ExternalNames.insert("llvm.dbg.compile_units"); 137 ExternalNames.insert("llvm.dbg.global_variables"); 138 ExternalNames.insert("llvm.dbg.subprograms"); 139 ExternalNames.insert("llvm.global_ctors"); 140 ExternalNames.insert("llvm.global_dtors"); 141 ExternalNames.insert("llvm.noinline"); 142 ExternalNames.insert("llvm.global.annotations"); 143 144 // Mark all global variables with initializers that are not in the api as 145 // internal as well. 146 for (Module::global_iterator I = M.global_begin(), E = M.global_end(); 147 I != E; ++I) 148 if (!I->isDeclaration() && !I->hasInternalLinkage() && 149 !ExternalNames.count(I->getName())) { 150 I->setLinkage(GlobalValue::InternalLinkage); 151 Changed = true; 152 ++NumGlobals; 153 DOUT << "Internalized gvar " << I->getName() << "\n"; 154 } 155 156 return Changed; 157} 158 159ModulePass *llvm::createInternalizePass(bool AllButMain) { 160 return new InternalizePass(AllButMain); 161} 162 163ModulePass *llvm::createInternalizePass(const std::vector <const char *> &el) { 164 return new InternalizePass(el); 165} 166