LLVM 17.0.0git
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
14#include "llvm/IR/Module.h"
15#include "llvm/IR/PassManager.h"
16#include <algorithm>
17
18using namespace llvm;
19
20/// Make sure GV is visible from both modules. Delete is true if it is
21/// being deleted from this module.
22/// This also makes sure GV cannot be dropped so that references from
23/// the split module remain valid.
24static void makeVisible(GlobalValue &GV, bool Delete) {
25 bool Local = GV.hasLocalLinkage();
26 if (Local || Delete) {
28 if (Local)
30 return;
31 }
32
33 if (!GV.hasLinkOnceLinkage()) {
35 return;
36 }
37
38 // Map linkonce* to weak* so that llvm doesn't drop this GV.
39 switch(GV.getLinkage()) {
40 default:
41 llvm_unreachable("Unexpected linkage");
44 return;
47 return;
48 }
49}
50
51
52 /// If deleteS is true, this pass deletes the specified global values.
53 /// Otherwise, it deletes as much of the module as possible, except for the
54 /// global values specified.
55ExtractGVPass::ExtractGVPass(std::vector<GlobalValue *> &GVs, bool deleteS,
56 bool keepConstInit)
57 : Named(GVs.begin(), GVs.end()), deleteStuff(deleteS),
58 keepConstInit(keepConstInit) {}
59
61 // Visit the global inline asm.
62 if (!deleteStuff)
63 M.setModuleInlineAsm("");
64
65 // For simplicity, just give all GlobalValues ExternalLinkage. A trickier
66 // implementation could figure out which GlobalValues are actually
67 // referenced by the Named set, and which GlobalValues in the rest of
68 // the module are referenced by the NamedSet, and get away with leaving
69 // more internal and private things internal and private. But for now,
70 // be conservative and simple.
71
72 // Visit the GlobalVariables.
73 for (GlobalVariable &GV : M.globals()) {
74 bool Delete = deleteStuff == (bool)Named.count(&GV) &&
75 !GV.isDeclaration() && (!GV.isConstant() || !keepConstInit);
76 if (!Delete) {
77 if (GV.hasAvailableExternallyLinkage())
78 continue;
79 if (GV.getName() == "llvm.global_ctors")
80 continue;
81 }
82
83 makeVisible(GV, Delete);
84
85 if (Delete) {
86 // Make this a declaration and drop it's comdat.
87 GV.setInitializer(nullptr);
88 GV.setComdat(nullptr);
89 }
90 }
91
92 // Visit the Functions.
93 for (Function &F : M) {
94 bool Delete = deleteStuff == (bool)Named.count(&F) && !F.isDeclaration();
95 if (!Delete) {
96 if (F.hasAvailableExternallyLinkage())
97 continue;
98 }
99
100 makeVisible(F, Delete);
101
102 if (Delete) {
103 // Make this a declaration and drop it's comdat.
104 F.deleteBody();
105 F.setComdat(nullptr);
106 }
107 }
108
109 // Visit the Aliases.
110 for (GlobalAlias &GA : llvm::make_early_inc_range(M.aliases())) {
111 bool Delete = deleteStuff == (bool)Named.count(&GA);
112 makeVisible(GA, Delete);
113
114 if (Delete) {
115 Type *Ty = GA.getValueType();
116
117 GA.removeFromParent();
118 llvm::Value *Declaration;
119 if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
121 GA.getAddressSpace(), GA.getName(), &M);
122
123 } else {
124 Declaration = new GlobalVariable(
125 M, Ty, false, GlobalValue::ExternalLinkage, nullptr, GA.getName());
126 }
127 GA.replaceAllUsesWith(Declaration);
128 delete &GA;
129 }
130 }
131
133}
static void makeVisible(GlobalValue &GV, bool Delete)
Make sure GV is visible from both modules.
Definition: ExtractGV.cpp:24
#define F(x, y, z)
Definition: MD5.cpp:55
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
ExtractGVPass(std::vector< GlobalValue * > &GVs, bool deleteS=true, bool keepConstInit=false)
If deleteS is true, this pass deletes the specified global values.
Definition: ExtractGV.cpp:55
PreservedAnalyses run(Module &M, ModuleAnalysisManager &)
Definition: ExtractGV.cpp:60
Class to represent function types.
Definition: DerivedTypes.h:103
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:510
LinkageTypes getLinkage() const
Definition: GlobalValue.h:541
bool hasLocalLinkage() const
Definition: GlobalValue.h:523
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:532
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:64
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:250
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:444
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:50
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:155
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:748