[llvm-extract] Drop comdats from declarations
[oota-llvm.git] / lib / Transforms / IPO / ExtractGV.cpp
1 //===-- ExtractGV.cpp - Global Value extraction pass ----------------------===//
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 extracts global values
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/Transforms/IPO.h"
15 #include "llvm/ADT/SetVector.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Instructions.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Pass.h"
21 #include <algorithm>
22 using namespace llvm;
23
24 /// Make sure GV is visible from both modules. Delete is true if it is
25 /// being deleted from this module.
26 /// This also makes sure GV cannot be dropped so that references from
27 /// the split module remain valid.
28 static void makeVisible(GlobalValue &GV, bool Delete) {
29   bool Local = GV.hasLocalLinkage();
30   if (Local || Delete) {
31     GV.setLinkage(GlobalValue::ExternalLinkage);
32     if (Local)
33       GV.setVisibility(GlobalValue::HiddenVisibility);
34     return;
35   }
36
37   if (!GV.hasLinkOnceLinkage()) {
38     assert(!GV.isDiscardableIfUnused());
39     return;
40   }
41
42   // Map linkonce* to weak* so that llvm doesn't drop this GV.
43   switch(GV.getLinkage()) {
44   default:
45     llvm_unreachable("Unexpected linkage");
46   case GlobalValue::LinkOnceAnyLinkage:
47     GV.setLinkage(GlobalValue::WeakAnyLinkage);
48     return;
49   case GlobalValue::LinkOnceODRLinkage:
50     GV.setLinkage(GlobalValue::WeakODRLinkage);
51     return;
52   }
53 }
54
55 namespace {
56   /// @brief A pass to extract specific functions and their dependencies.
57   class GVExtractorPass : public ModulePass {
58     SetVector<GlobalValue *> Named;
59     bool deleteStuff;
60   public:
61     static char ID; // Pass identification, replacement for typeid
62
63     /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the
64     /// specified function. Otherwise, it deletes as much of the module as
65     /// possible, except for the function specified.
66     ///
67     explicit GVExtractorPass(std::vector<GlobalValue*>& GVs, bool deleteS = true)
68       : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS) {}
69
70     bool runOnModule(Module &M) override {
71       // Visit the global inline asm.
72       if (!deleteStuff)
73         M.setModuleInlineAsm("");
74
75       // For simplicity, just give all GlobalValues ExternalLinkage. A trickier
76       // implementation could figure out which GlobalValues are actually
77       // referenced by the Named set, and which GlobalValues in the rest of
78       // the module are referenced by the NamedSet, and get away with leaving
79       // more internal and private things internal and private. But for now,
80       // be conservative and simple.
81
82       // Visit the GlobalVariables.
83       for (Module::global_iterator I = M.global_begin(), E = M.global_end();
84            I != E; ++I) {
85         bool Delete =
86           deleteStuff == (bool)Named.count(I) && !I->isDeclaration();
87         if (!Delete) {
88           if (I->hasAvailableExternallyLinkage())
89             continue;
90           if (I->getName() == "llvm.global_ctors")
91             continue;
92         }
93
94         makeVisible(*I, Delete);
95
96         if (Delete) {
97           // Make this a declaration and drop it's comdat.
98           I->setInitializer(nullptr);
99           I->setComdat(nullptr);
100         }
101       }
102
103       // Visit the Functions.
104       for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
105         bool Delete =
106           deleteStuff == (bool)Named.count(I) && !I->isDeclaration();
107         if (!Delete) {
108           if (I->hasAvailableExternallyLinkage())
109             continue;
110         }
111
112         makeVisible(*I, Delete);
113
114         if (Delete) {
115           // Make this a declaration and drop it's comdat.
116           I->deleteBody();
117           I->setComdat(nullptr);
118         }
119       }
120
121       // Visit the Aliases.
122       for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
123            I != E;) {
124         Module::alias_iterator CurI = I;
125         ++I;
126
127         bool Delete = deleteStuff == (bool)Named.count(CurI);
128         makeVisible(*CurI, Delete);
129
130         if (Delete) {
131           Type *Ty =  CurI->getType()->getElementType();
132
133           CurI->removeFromParent();
134           llvm::Value *Declaration;
135           if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
136             Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
137                                            CurI->getName(), &M);
138
139           } else {
140             Declaration =
141               new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage,
142                                  nullptr, CurI->getName());
143
144           }
145           CurI->replaceAllUsesWith(Declaration);
146           delete CurI;
147         }
148       }
149
150       return true;
151     }
152   };
153
154   char GVExtractorPass::ID = 0;
155 }
156
157 ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue *> &GVs,
158                                          bool deleteFn) {
159   return new GVExtractorPass(GVs, deleteFn);
160 }