LLVM  9.0.0svn
ExtractGV.cpp
Go to the documentation of this file.
1 //===-- ExtractGV.cpp - Global Value extraction pass ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass extracts global values
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/ADT/SetVector.h"
14 #include "llvm/IR/LLVMContext.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/Pass.h"
17 #include "llvm/Transforms/IPO.h"
18 #include <algorithm>
19 using namespace llvm;
20 
21 /// Make sure GV is visible from both modules. Delete is true if it is
22 /// being deleted from this module.
23 /// This also makes sure GV cannot be dropped so that references from
24 /// the split module remain valid.
25 static void makeVisible(GlobalValue &GV, bool Delete) {
26  bool Local = GV.hasLocalLinkage();
27  if (Local || Delete) {
29  if (Local)
31  return;
32  }
33 
34  if (!GV.hasLinkOnceLinkage()) {
36  return;
37  }
38 
39  // Map linkonce* to weak* so that llvm doesn't drop this GV.
40  switch(GV.getLinkage()) {
41  default:
42  llvm_unreachable("Unexpected linkage");
45  return;
48  return;
49  }
50 }
51 
52 namespace {
53  /// A pass to extract specific global values and their dependencies.
54  class GVExtractorPass : public ModulePass {
56  bool deleteStuff;
57  public:
58  static char ID; // Pass identification, replacement for typeid
59 
60  /// If deleteS is true, this pass deletes the specified global values.
61  /// Otherwise, it deletes as much of the module as possible, except for the
62  /// global values specified.
63  explicit GVExtractorPass(std::vector<GlobalValue*> &GVs,
64  bool deleteS = true)
65  : ModulePass(ID), Named(GVs.begin(), GVs.end()), deleteStuff(deleteS) {}
66 
67  bool runOnModule(Module &M) override {
68  if (skipModule(M))
69  return false;
70 
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.
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 (Function &F : M) {
105  bool Delete =
106  deleteStuff == (bool)Named.count(&F) && !F.isDeclaration();
107  if (!Delete) {
108  if (F.hasAvailableExternallyLinkage())
109  continue;
110  }
111 
112  makeVisible(F, Delete);
113 
114  if (Delete) {
115  // Make this a declaration and drop it's comdat.
116  F.deleteBody();
117  F.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->getValueType();
132 
133  CurI->removeFromParent();
134  llvm::Value *Declaration;
135  if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
137  CurI->getAddressSpace(),
138  CurI->getName(), &M);
139 
140  } else {
141  Declaration =
143  nullptr, CurI->getName());
144 
145  }
146  CurI->replaceAllUsesWith(Declaration);
147  delete &*CurI;
148  }
149  }
150 
151  return true;
152  }
153  };
154 
155  char GVExtractorPass::ID = 0;
156 }
157 
158 ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue *> &GVs,
159  bool deleteFn) {
160  return new GVExtractorPass(GVs, deleteFn);
161 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:238
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
ModulePass * createGVExtractionPass(std::vector< GlobalValue *> &GVs, bool deleteFn=false)
createGVExtractionPass - If deleteFn is true, this pass deletes the specified global values...
Definition: ExtractGV.cpp:158
Externally visible function.
Definition: GlobalValue.h:48
F(f)
void setModuleInlineAsm(StringRef Asm)
Set the module-scope inline assembly blocks.
Definition: Module.h:287
global_iterator global_begin()
Definition: Module.h:581
Class to represent function types.
Definition: DerivedTypes.h:102
LinkageTypes getLinkage() const
Definition: GlobalValue.h:450
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:425
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:210
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:135
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static bool isDiscardableIfUnused(LinkageTypes Linkage)
Whether the definition of this global may be discarded if it is not used in its compilation unit...
Definition: GlobalValue.h:360
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
global_iterator global_end()
Definition: Module.h:583
Iterator for intrusive lists based on ilist_node.
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:50
Module.h This file contains the declarations for the Module class.
static void makeVisible(GlobalValue &GV, bool Delete)
Make sure GV is visible from both modules.
Definition: ExtractGV.cpp:25
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:444
#define I(x, y, z)
Definition: MD5.cpp:58
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:72
A vector that has set insertion semantics.
Definition: SetVector.h:40