LLVM  6.0.0svn
FunctionImportUtils.cpp
Go to the documentation of this file.
1 //===- lib/Transforms/Utils/FunctionImportUtils.cpp - Importing utilities -===//
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 file implements the FunctionImportGlobalProcessing class, used
11 // to perform the necessary global value handling for function importing.
12 //
13 //===----------------------------------------------------------------------===//
14 
17 #include "llvm/IR/InstIterator.h"
18 #include "llvm/IR/Instructions.h"
19 using namespace llvm;
20 
21 /// Checks if we should import SGV as a definition, otherwise import as a
22 /// declaration.
23 bool FunctionImportGlobalProcessing::doImportAsDefinition(
24  const GlobalValue *SGV, SetVector<GlobalValue *> *GlobalsToImport) {
25 
26  // Only import the globals requested for importing.
27  if (!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)))
28  return false;
29 
30  assert(!isa<GlobalAlias>(SGV) &&
31  "Unexpected global alias in the import list.");
32 
33  // Otherwise yes.
34  return true;
35 }
36 
37 bool FunctionImportGlobalProcessing::doImportAsDefinition(
38  const GlobalValue *SGV) {
39  if (!isPerformingImport())
40  return false;
41  return FunctionImportGlobalProcessing::doImportAsDefinition(SGV,
42  GlobalsToImport);
43 }
44 
45 bool FunctionImportGlobalProcessing::shouldPromoteLocalToGlobal(
46  const GlobalValue *SGV) {
47  assert(SGV->hasLocalLinkage());
48  // Both the imported references and the original local variable must
49  // be promoted.
50  if (!isPerformingImport() && !isModuleExporting())
51  return false;
52 
53  if (isPerformingImport()) {
54  assert((!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)) ||
55  !isNonRenamableLocal(*SGV)) &&
56  "Attempting to promote non-renamable local");
57  // We don't know for sure yet if we are importing this value (as either
58  // a reference or a def), since we are simply walking all values in the
59  // module. But by necessity if we end up importing it and it is local,
60  // it must be promoted, so unconditionally promote all values in the
61  // importing module.
62  return true;
63  }
64 
65  // When exporting, consult the index. We can have more than one local
66  // with the same GUID, in the case of same-named locals in different but
67  // same-named source files that were compiled in their respective directories
68  // (so the source file name and resulting GUID is the same). Find the one
69  // in this module.
70  auto Summary = ImportIndex.findSummaryInModule(
71  SGV->getGUID(), SGV->getParent()->getModuleIdentifier());
72  assert(Summary && "Missing summary for global value when exporting");
73  auto Linkage = Summary->linkage();
74  if (!GlobalValue::isLocalLinkage(Linkage)) {
75  assert(!isNonRenamableLocal(*SGV) &&
76  "Attempting to promote non-renamable local");
77  return true;
78  }
79 
80  return false;
81 }
82 
83 #ifndef NDEBUG
84 bool FunctionImportGlobalProcessing::isNonRenamableLocal(
85  const GlobalValue &GV) const {
86  if (!GV.hasLocalLinkage())
87  return false;
88  // This needs to stay in sync with the logic in buildModuleSummaryIndex.
89  if (GV.hasSection())
90  return true;
91  if (Used.count(const_cast<GlobalValue *>(&GV)))
92  return true;
93  return false;
94 }
95 #endif
96 
97 std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV,
98  bool DoPromote) {
99  // For locals that must be promoted to global scope, ensure that
100  // the promoted name uniquely identifies the copy in the original module,
101  // using the ID assigned during combined index creation. When importing,
102  // we rename all locals (not just those that are promoted) in order to
103  // avoid naming conflicts between locals imported from different modules.
104  if (SGV->hasLocalLinkage() && (DoPromote || isPerformingImport()))
106  SGV->getName(),
107  ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier()));
108  return SGV->getName();
109 }
110 
112 FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV,
113  bool DoPromote) {
114  // Any local variable that is referenced by an exported function needs
115  // to be promoted to global scope. Since we don't currently know which
116  // functions reference which local variables/functions, we must treat
117  // all as potentially exported if this module is exporting anything.
118  if (isModuleExporting()) {
119  if (SGV->hasLocalLinkage() && DoPromote)
121  return SGV->getLinkage();
122  }
123 
124  // Otherwise, if we aren't importing, no linkage change is needed.
125  if (!isPerformingImport())
126  return SGV->getLinkage();
127 
128  switch (SGV->getLinkage()) {
132  // External and linkonce definitions are converted to available_externally
133  // definitions upon import, so that they are available for inlining
134  // and/or optimization, but are turned into declarations later
135  // during the EliminateAvailableExternally pass.
136  if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
138  // An imported external declaration stays external.
139  return SGV->getLinkage();
140 
142  // An imported available_externally definition converts
143  // to external if imported as a declaration.
144  if (!doImportAsDefinition(SGV))
146  // An imported available_externally declaration stays that way.
147  return SGV->getLinkage();
148 
150  // Can't import weak_any definitions correctly, or we might change the
151  // program semantics, since the linker will pick the first weak_any
152  // definition and importing would change the order they are seen by the
153  // linker. The module linking caller needs to enforce this.
154  assert(!doImportAsDefinition(SGV));
155  // If imported as a declaration, it becomes external_weak.
156  return SGV->getLinkage();
157 
159  // For weak_odr linkage, there is a guarantee that all copies will be
160  // equivalent, so the issue described above for weak_any does not exist,
161  // and the definition can be imported. It can be treated similarly
162  // to an imported externally visible global value.
163  if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
165  else
167 
169  // It would be incorrect to import an appending linkage variable,
170  // since it would cause global constructors/destructors to be
171  // executed multiple times. This should have already been handled
172  // by linkIfNeeded, and we will assert in shouldLinkFromSource
173  // if we try to import, so we simply return AppendingLinkage.
175 
178  // If we are promoting the local to global scope, it is handled
179  // similarly to a normal externally visible global.
180  if (DoPromote) {
181  if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
183  else
185  }
186  // A non-promoted imported local definition stays local.
187  // The ThinLTO pass will eventually force-import their definitions.
188  return SGV->getLinkage();
189 
191  // External weak doesn't apply to definitions, must be a declaration.
192  assert(!doImportAsDefinition(SGV));
193  // Linkage stays external_weak.
194  return SGV->getLinkage();
195 
197  // Linkage stays common on definitions.
198  // The ThinLTO pass will eventually force-import their definitions.
199  return SGV->getLinkage();
200  }
201 
202  llvm_unreachable("unknown linkage type");
203 }
204 
205 void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) {
206 
207  // Check the summaries to see if the symbol gets resolved to a known local
208  // definition.
209  if (GV.hasName()) {
210  ValueInfo VI = ImportIndex.getValueInfo(GV.getGUID());
211  if (VI) {
212  // Need to check all summaries are local in case of hash collisions.
213  bool IsLocal = VI.getSummaryList().size() &&
215  [](const std::unique_ptr<GlobalValueSummary> &Summary) {
216  return Summary->isDSOLocal();
217  });
218  if (IsLocal)
219  GV.setDSOLocal(true);
220  }
221  }
222 
223  bool DoPromote = false;
224  if (GV.hasLocalLinkage() &&
225  ((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) {
226  // Once we change the name or linkage it is difficult to determine
227  // again whether we should promote since shouldPromoteLocalToGlobal needs
228  // to locate the summary (based on GUID from name and linkage). Therefore,
229  // use DoPromote result saved above.
230  GV.setName(getName(&GV, DoPromote));
231  GV.setLinkage(getLinkage(&GV, DoPromote));
232  if (!GV.hasLocalLinkage())
234  } else
235  GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
236 
237  // Remove functions imported as available externally defs from comdats,
238  // as this is a declaration for the linker, and will be dropped eventually.
239  // It is illegal for comdats to contain declarations.
240  auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
241  if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
242  // The IRMover should not have placed any imported declarations in
243  // a comdat, so the only declaration that should be in a comdat
244  // at this point would be a definition imported as available_externally.
245  assert(GO->hasAvailableExternallyLinkage() &&
246  "Expected comdat on definition (possibly available external)");
247  GO->setComdat(nullptr);
248  }
249 }
250 
251 void FunctionImportGlobalProcessing::processGlobalsForThinLTO() {
252  for (GlobalVariable &GV : M.globals())
253  processGlobalForThinLTO(GV);
254  for (Function &SF : M)
255  processGlobalForThinLTO(SF);
256  for (GlobalAlias &GA : M.aliases())
257  processGlobalForThinLTO(GA);
258 }
259 
261  processGlobalsForThinLTO();
262  return false;
263 }
264 
266  SetVector<GlobalValue *> *GlobalsToImport) {
267  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport);
268  return ThinLTOProcessing.run();
269 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:231
bool hasLocalLinkage() const
Definition: GlobalValue.h:427
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:55
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
ValueInfo getValueInfo(GlobalValue::GUID GUID) const
Return a ValueInfo for GUID if it exists, otherwise return ValueInfo().
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:54
GlobalValueSummary * findSummaryInModule(GlobalValue::GUID ValueGUID, StringRef ModuleId) const
Find the summary for global GUID in module ModuleId, or nullptr if not found.
This is the interface to build a ModuleSummaryIndex for a module.
Available for inspection, not emission.
Definition: GlobalValue.h:50
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:57
Externally visible function.
Definition: GlobalValue.h:49
Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:767
Tentative definitions.
Definition: GlobalValue.h:59
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:312
bool hasSection() const
Definition: GlobalValue.h:261
static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash)
Convenience method for creating a promoted global name for the given value name of a local...
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:286
LinkageTypes getLinkage() const
Definition: GlobalValue.h:441
Class to hold module path string table and global value map, and encapsulate methods for operating on...
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:211
ExternalWeak linkage description.
Definition: GlobalValue.h:58
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:52
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, SetVector< GlobalValue *> *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
bool hasName() const
Definition: Value.h:251
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:487
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:208
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Struct that holds a reference to a particular GUID in a global value summary.
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:51
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:436
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:220
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:53
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:556
A vector that has set insertion semantics.
Definition: SetVector.h:41
iterator_range< global_iterator > globals()
Definition: Module.h:561
void setDSOLocal(bool Local)
Definition: GlobalValue.h:269