Add an option to this pass. If it is set, we are allowed to internalize
[oota-llvm.git] / lib / Transforms / IPO / Internalize.cpp
1 //===-- Internalize.cpp - Mark functions internal -------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source 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 #include "llvm/Transforms/IPO.h"
17 #include "llvm/Pass.h"
18 #include "llvm/Module.h"
19 #include "llvm/Support/CommandLine.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/ADT/Statistic.h"
22 #include <fstream>
23 #include <set>
24 using namespace llvm;
25
26 namespace {
27   Statistic<> NumFunctions("internalize", "Number of functions internalized");
28   Statistic<> NumGlobals  ("internalize", "Number of global vars internalized");
29
30   // APIFile - A file which contains a list of symbols that should not be marked
31   // external.
32   cl::opt<std::string>
33   APIFile("internalize-public-api-file", cl::value_desc("filename"),
34           cl::desc("A file containing list of symbol names to preserve"));
35
36   // APIList - A list of symbols that should not be marked internal.
37   cl::list<std::string>
38   APIList("internalize-public-api-list", cl::value_desc("list"),
39           cl::desc("A list of symbol names to preserve"),
40           cl::CommaSeparated);
41
42   class InternalizePass : public ModulePass {
43     std::set<std::string> ExternalNames;
44     bool DontInternalize;
45   public:
46     InternalizePass(bool InternalizeEverything = true) : DontInternalize(false){
47       if (!APIFile.empty())           // If a filename is specified, use it
48         LoadFile(APIFile.c_str());
49       else if (!APIList.empty())      // Else, if a list is specified, use it.
50         ExternalNames.insert(APIList.begin(), APIList.end());
51       else if (!InternalizeEverything)
52         // Finally, if we're allowed to, internalize all but main.
53         DontInternalize = true;
54     }
55
56     void LoadFile(const char *Filename) {
57       // Load the APIFile...
58       std::ifstream In(Filename);
59       if (!In.good()) {
60         std::cerr << "WARNING: Internalize couldn't load file '" << Filename
61                   << "'!\n";
62         return;   // Do not internalize anything...
63       }
64       while (In) {
65         std::string Symbol;
66         In >> Symbol;
67         if (!Symbol.empty())
68           ExternalNames.insert(Symbol);
69       }
70     }
71
72     virtual bool runOnModule(Module &M) {
73       if (DontInternalize) return false;
74       
75       // If no list or file of symbols was specified, check to see if there is a
76       // "main" symbol defined in the module.  If so, use it, otherwise do not
77       // internalize the module, it must be a library or something.
78       //
79       if (ExternalNames.empty()) {
80         Function *MainFunc = M.getMainFunction();
81         if (MainFunc == 0 || MainFunc->isExternal())
82           return false;  // No main found, must be a library...
83
84         // Preserve main, internalize all else.
85         ExternalNames.insert(MainFunc->getName());
86       }
87
88       bool Changed = false;
89
90       // Found a main function, mark all functions not named main as internal.
91       for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
92         if (!I->isExternal() &&         // Function must be defined here
93             !I->hasInternalLinkage() &&  // Can't already have internal linkage
94             !ExternalNames.count(I->getName())) {// Not marked to keep external?
95           I->setLinkage(GlobalValue::InternalLinkage);
96           Changed = true;
97           ++NumFunctions;
98           DEBUG(std::cerr << "Internalizing func " << I->getName() << "\n");
99         }
100
101       // Mark all global variables with initializers as internal as well...
102       for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
103         if (!I->isExternal() && !I->hasInternalLinkage() &&
104             !ExternalNames.count(I->getName())) {
105           // Special case handling of the global ctor and dtor list.  When we
106           // internalize it, we mark it constant, which allows elimination of
107           // the list if it's empty.
108           //
109           if (I->hasAppendingLinkage() && (I->getName() == "llvm.global_ctors"||
110                                            I->getName() == "llvm.global_dtors"))
111             I->setConstant(true);
112
113           I->setLinkage(GlobalValue::InternalLinkage);
114           Changed = true;
115           ++NumGlobals;
116           DEBUG(std::cerr << "Internalizing gvar " << I->getName() << "\n");
117         }
118
119       return Changed;
120     }
121   };
122
123   RegisterOpt<InternalizePass> X("internalize", "Internalize Global Symbols");
124 } // end anonymous namespace
125
126 ModulePass *llvm::createInternalizePass(bool InternalizeEverything) {
127   return new InternalizePass(InternalizeEverything);
128 }