LLVM  15.0.0git
FunctionImportUtils.cpp
Go to the documentation of this file.
1 //===- lib/Transforms/Utils/FunctionImportUtils.cpp - Importing utilities -===//
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 file implements the FunctionImportGlobalProcessing class, used
10 // to perform the necessary global value handling for function importing.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 using namespace llvm;
16 
17 /// Checks if we should import SGV as a definition, otherwise import as a
18 /// declaration.
19 bool FunctionImportGlobalProcessing::doImportAsDefinition(
20  const GlobalValue *SGV) {
21  if (!isPerformingImport())
22  return false;
23 
24  // Only import the globals requested for importing.
25  if (!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)))
26  return false;
27 
28  assert(!isa<GlobalAlias>(SGV) &&
29  "Unexpected global alias in the import list.");
30 
31  // Otherwise yes.
32  return true;
33 }
34 
35 bool FunctionImportGlobalProcessing::shouldPromoteLocalToGlobal(
36  const GlobalValue *SGV, ValueInfo VI) {
37  assert(SGV->hasLocalLinkage());
38  // Both the imported references and the original local variable must
39  // be promoted.
40  if (!isPerformingImport() && !isModuleExporting())
41  return false;
42 
43  if (isPerformingImport()) {
44  assert((!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)) ||
45  !isNonRenamableLocal(*SGV)) &&
46  "Attempting to promote non-renamable local");
47  // We don't know for sure yet if we are importing this value (as either
48  // a reference or a def), since we are simply walking all values in the
49  // module. But by necessity if we end up importing it and it is local,
50  // it must be promoted, so unconditionally promote all values in the
51  // importing module.
52  return true;
53  }
54 
55  // When exporting, consult the index. We can have more than one local
56  // with the same GUID, in the case of same-named locals in different but
57  // same-named source files that were compiled in their respective directories
58  // (so the source file name and resulting GUID is the same). Find the one
59  // in this module.
60  auto Summary = ImportIndex.findSummaryInModule(
61  VI, SGV->getParent()->getModuleIdentifier());
62  assert(Summary && "Missing summary for global value when exporting");
63  auto Linkage = Summary->linkage();
64  if (!GlobalValue::isLocalLinkage(Linkage)) {
65  assert(!isNonRenamableLocal(*SGV) &&
66  "Attempting to promote non-renamable local");
67  return true;
68  }
69 
70  return false;
71 }
72 
73 #ifndef NDEBUG
74 bool FunctionImportGlobalProcessing::isNonRenamableLocal(
75  const GlobalValue &GV) const {
76  if (!GV.hasLocalLinkage())
77  return false;
78  // This needs to stay in sync with the logic in buildModuleSummaryIndex.
79  if (GV.hasSection())
80  return true;
81  if (Used.count(const_cast<GlobalValue *>(&GV)))
82  return true;
83  return false;
84 }
85 #endif
86 
87 std::string
88 FunctionImportGlobalProcessing::getPromotedName(const GlobalValue *SGV) {
89  assert(SGV->hasLocalLinkage());
90  // For locals that must be promoted to global scope, ensure that
91  // the promoted name uniquely identifies the copy in the original module,
92  // using the ID assigned during combined index creation.
94  SGV->getName(),
95  ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier()));
96 }
97 
99 FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV,
100  bool DoPromote) {
101  // Any local variable that is referenced by an exported function needs
102  // to be promoted to global scope. Since we don't currently know which
103  // functions reference which local variables/functions, we must treat
104  // all as potentially exported if this module is exporting anything.
105  if (isModuleExporting()) {
106  if (SGV->hasLocalLinkage() && DoPromote)
108  return SGV->getLinkage();
109  }
110 
111  // Otherwise, if we aren't importing, no linkage change is needed.
112  if (!isPerformingImport())
113  return SGV->getLinkage();
114 
115  switch (SGV->getLinkage()) {
118  // External and linkonce definitions are converted to available_externally
119  // definitions upon import, so that they are available for inlining
120  // and/or optimization, but are turned into declarations later
121  // during the EliminateAvailableExternally pass.
122  if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
124  // An imported external declaration stays external.
125  return SGV->getLinkage();
126 
128  // An imported available_externally definition converts
129  // to external if imported as a declaration.
130  if (!doImportAsDefinition(SGV))
132  // An imported available_externally declaration stays that way.
133  return SGV->getLinkage();
134 
137  // Can't import linkonce_any/weak_any definitions correctly, or we might
138  // change the program semantics, since the linker will pick the first
139  // linkonce_any/weak_any definition and importing would change the order
140  // they are seen by the linker. The module linking caller needs to enforce
141  // this.
142  assert(!doImportAsDefinition(SGV));
143  // If imported as a declaration, it becomes external_weak.
144  return SGV->getLinkage();
145 
147  // For weak_odr linkage, there is a guarantee that all copies will be
148  // equivalent, so the issue described above for weak_any does not exist,
149  // and the definition can be imported. It can be treated similarly
150  // to an imported externally visible global value.
151  if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
153  else
155 
157  // It would be incorrect to import an appending linkage variable,
158  // since it would cause global constructors/destructors to be
159  // executed multiple times. This should have already been handled
160  // by linkIfNeeded, and we will assert in shouldLinkFromSource
161  // if we try to import, so we simply return AppendingLinkage.
163 
166  // If we are promoting the local to global scope, it is handled
167  // similarly to a normal externally visible global.
168  if (DoPromote) {
169  if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
171  else
173  }
174  // A non-promoted imported local definition stays local.
175  // The ThinLTO pass will eventually force-import their definitions.
176  return SGV->getLinkage();
177 
179  // External weak doesn't apply to definitions, must be a declaration.
180  assert(!doImportAsDefinition(SGV));
181  // Linkage stays external_weak.
182  return SGV->getLinkage();
183 
185  // Linkage stays common on definitions.
186  // The ThinLTO pass will eventually force-import their definitions.
187  return SGV->getLinkage();
188  }
189 
190  llvm_unreachable("unknown linkage type");
191 }
192 
193 void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) {
194 
195  ValueInfo VI;
196  if (GV.hasName()) {
197  VI = ImportIndex.getValueInfo(GV.getGUID());
198  // Set synthetic function entry counts.
199  if (VI && ImportIndex.hasSyntheticEntryCounts()) {
200  if (Function *F = dyn_cast<Function>(&GV)) {
201  if (!F->isDeclaration()) {
202  for (auto &S : VI.getSummaryList()) {
203  auto *FS = cast<FunctionSummary>(S->getBaseObject());
204  if (FS->modulePath() == M.getModuleIdentifier()) {
205  F->setEntryCount(Function::ProfileCount(FS->entryCount(),
207  break;
208  }
209  }
210  }
211  }
212  }
213  }
214 
215  // We should always have a ValueInfo (i.e. GV in index) for definitions when
216  // we are exporting, and also when importing that value.
217  assert(VI || GV.isDeclaration() ||
218  (isPerformingImport() && !doImportAsDefinition(&GV)));
219 
220  // Mark read/write-only variables which can be imported with specific
221  // attribute. We can't internalize them now because IRMover will fail
222  // to link variable definitions to their external declarations during
223  // ThinLTO import. We'll internalize read-only variables later, after
224  // import is finished. See internalizeGVsAfterImport.
225  //
226  // If global value dead stripping is not enabled in summary then
227  // propagateConstants hasn't been run. We can't internalize GV
228  // in such case.
229  if (!GV.isDeclaration() && VI && ImportIndex.withAttributePropagation()) {
230  if (GlobalVariable *V = dyn_cast<GlobalVariable>(&GV)) {
231  // We can have more than one local with the same GUID, in the case of
232  // same-named locals in different but same-named source files that were
233  // compiled in their respective directories (so the source file name
234  // and resulting GUID is the same). Find the one in this module.
235  // Handle the case where there is no summary found in this module. That
236  // can happen in the distributed ThinLTO backend, because the index only
237  // contains summaries from the source modules if they are being imported.
238  // We might have a non-null VI and get here even in that case if the name
239  // matches one in this module (e.g. weak or appending linkage).
240  auto *GVS = dyn_cast_or_null<GlobalVarSummary>(
241  ImportIndex.findSummaryInModule(VI, M.getModuleIdentifier()));
242  if (GVS &&
243  (ImportIndex.isReadOnly(GVS) || ImportIndex.isWriteOnly(GVS))) {
244  V->addAttribute("thinlto-internalize");
245  // Objects referenced by writeonly GV initializer should not be
246  // promoted, because there is no any kind of read access to them
247  // on behalf of this writeonly GV. To avoid promotion we convert
248  // GV initializer to 'zeroinitializer'. This effectively drops
249  // references in IR module (not in combined index), so we can
250  // ignore them when computing import. We do not export references
251  // of writeonly object. See computeImportForReferencedGlobals
252  if (ImportIndex.isWriteOnly(GVS))
253  V->setInitializer(Constant::getNullValue(V->getValueType()));
254  }
255  }
256  }
257 
258  if (GV.hasLocalLinkage() && shouldPromoteLocalToGlobal(&GV, VI)) {
259  // Save the original name string before we rename GV below.
260  auto Name = GV.getName().str();
261  GV.setName(getPromotedName(&GV));
262  GV.setLinkage(getLinkage(&GV, /* DoPromote */ true));
263  assert(!GV.hasLocalLinkage());
265 
266  // If we are renaming a COMDAT leader, ensure that we record the COMDAT
267  // for later renaming as well. This is required for COFF.
268  if (const auto *C = GV.getComdat())
269  if (C->getName() == Name)
270  RenamedComdats.try_emplace(C, M.getOrInsertComdat(GV.getName()));
271  } else
272  GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
273 
274  // When ClearDSOLocalOnDeclarations is true, clear dso_local if GV is
275  // converted to a declaration, to disable direct access. Don't do this if GV
276  // is implicitly dso_local due to a non-default visibility.
277  if (ClearDSOLocalOnDeclarations &&
278  (GV.isDeclarationForLinker() ||
279  (isPerformingImport() && !doImportAsDefinition(&GV))) &&
280  !GV.isImplicitDSOLocal()) {
281  GV.setDSOLocal(false);
282  } else if (VI && VI.isDSOLocal(ImportIndex.withDSOLocalPropagation())) {
283  // If all summaries are dso_local, symbol gets resolved to a known local
284  // definition.
285  GV.setDSOLocal(true);
286  if (GV.hasDLLImportStorageClass())
288  }
289 
290  // Remove functions imported as available externally defs from comdats,
291  // as this is a declaration for the linker, and will be dropped eventually.
292  // It is illegal for comdats to contain declarations.
293  auto *GO = dyn_cast<GlobalObject>(&GV);
294  if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
295  // The IRMover should not have placed any imported declarations in
296  // a comdat, so the only declaration that should be in a comdat
297  // at this point would be a definition imported as available_externally.
298  assert(GO->hasAvailableExternallyLinkage() &&
299  "Expected comdat on definition (possibly available external)");
300  GO->setComdat(nullptr);
301  }
302 }
303 
304 void FunctionImportGlobalProcessing::processGlobalsForThinLTO() {
305  for (GlobalVariable &GV : M.globals())
306  processGlobalForThinLTO(GV);
307  for (Function &SF : M)
308  processGlobalForThinLTO(SF);
309  for (GlobalAlias &GA : M.aliases())
310  processGlobalForThinLTO(GA);
311 
312  // Replace any COMDATS that required renaming (because the COMDAT leader was
313  // promoted and renamed).
314  if (!RenamedComdats.empty())
315  for (auto &GO : M.global_objects())
316  if (auto *C = GO.getComdat()) {
317  auto Replacement = RenamedComdats.find(C);
318  if (Replacement != RenamedComdats.end())
319  GO.setComdat(Replacement->second);
320  }
321 }
322 
324  processGlobalsForThinLTO();
325  return false;
326 }
327 
329  bool ClearDSOLocalOnDeclarations,
330  SetVector<GlobalValue *> *GlobalsToImport) {
331  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport,
332  ClearDSOLocalOnDeclarations);
333  return ThinLTOProcessing.run();
334 }
llvm::FunctionImportGlobalProcessing::run
bool run()
Definition: FunctionImportUtils.cpp:323
llvm::ModuleSummaryIndex::hasSyntheticEntryCounts
bool hasSyntheticEntryCounts() const
Definition: ModuleSummaryIndex.h:1290
FunctionImportUtils.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::GlobalValue::LinkOnceAnyLinkage
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:50
llvm::ModuleSummaryIndex::isReadOnly
bool isReadOnly(const GlobalVarSummary *GVS) const
Definition: ModuleSummaryIndex.h:1283
llvm::ModuleSummaryIndex::getModuleHash
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
Definition: ModuleSummaryIndex.h:1453
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:509
llvm::GlobalValue::HiddenVisibility
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:64
llvm::GlobalValue::isImplicitDSOLocal
bool isImplicitDSOLocal() const
Definition: GlobalValue.h:280
llvm::Function
Definition: Function.h:60
llvm::renameModuleForThinLTO
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, bool ClearDSOLocalOnDeclarations, SetVector< GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
Definition: FunctionImportUtils.cpp:328
llvm::GlobalValue::isLocalLinkage
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:374
llvm::Value::hasName
bool hasName() const
Definition: Value.h:261
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::GlobalAlias
Definition: GlobalAlias.h:28
llvm::GlobalValue::hasSection
bool hasSection() const
Definition: GlobalValue.h:272
llvm::GlobalValue::DefaultStorageClass
@ DefaultStorageClass
Definition: GlobalValue.h:70
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::GlobalValue::setDSOLocal
void setDSOLocal(bool Local)
Definition: GlobalValue.h:285
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::ModuleSummaryIndex::withDSOLocalPropagation
bool withDSOLocalPropagation() const
Definition: ModuleSummaryIndex.h:1280
llvm::Function::PCT_Synthetic
@ PCT_Synthetic
Definition: Function.h:248
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:264
llvm::Module::globals
iterator_range< global_iterator > globals()
Definition: Module.h:614
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:372
llvm::ModuleSummaryIndex::findSummaryInModule
GlobalValueSummary * findSummaryInModule(ValueInfo VI, StringRef ModuleId) const
Find the summary for ValueInfo VI in module ModuleId, or nullptr if not found.
Definition: ModuleSummaryIndex.h:1401
llvm::GlobalValue::InternalLinkage
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:249
llvm::GlobalValue::getGUID
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:555
llvm::ValueInfo
Struct that holds a reference to a particular GUID in a global value summary.
Definition: ModuleSummaryIndex.h:167
llvm::GlobalValue
Definition: GlobalValue.h:44
VI
@ VI
Definition: SIInstrInfo.cpp:7831
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:620
llvm::GlobalValue::WeakAnyLinkage
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
llvm::ModuleSummaryIndex::getValueInfo
ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const
Return a ValueInfo for the index value_type (convenient when iterating index).
Definition: ModuleSummaryIndex.h:1315
llvm::GlobalValue::setLinkage
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:502
llvm::Module::getOrInsertComdat
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:582
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::X86AS::FS
@ FS
Definition: X86.h:192
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:493
llvm::Module::getModuleIdentifier
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:228
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::GlobalValue::AppendingLinkage
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:54
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::GlobalValue::WeakODRLinkage
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
llvm::GlobalValue::setDLLStorageClass
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:270
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::GlobalValue::AvailableExternallyLinkage
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:49
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:305
llvm::GlobalValue::CommonLinkage
@ CommonLinkage
Tentative definitions.
Definition: GlobalValue.h:58
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::Constant::getNullValue
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:350
llvm::GlobalValue::getComdat
const Comdat * getComdat() const
Definition: Globals.cpp:181
llvm::FunctionImportGlobalProcessing
Class to handle necessary GlobalValue changes required by ThinLTO function importing,...
Definition: FunctionImportUtils.h:25
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
llvm::ModuleSummaryIndex::isWriteOnly
bool isWriteOnly(const GlobalVarSummary *GVS) const
Definition: ModuleSummaryIndex.h:1286
llvm::GlobalValue::PrivateLinkage
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1087
llvm::ModuleSummaryIndex::getGlobalNameForLocal
static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash)
Convenience method for creating a promoted global name for the given value name of a local,...
Definition: ModuleSummaryIndex.h:1461
llvm::GlobalValue::isDeclarationForLinker
bool isDeclarationForLinker() const
Definition: GlobalValue.h:582
llvm::GlobalValue::hasDLLImportStorageClass
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:264
llvm::ModuleSummaryIndex::withAttributePropagation
bool withAttributePropagation() const
Definition: ModuleSummaryIndex.h:1275
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:253
llvm::GlobalValue::ExternalWeakLinkage
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:57
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
llvm::GlobalValue::LinkOnceODRLinkage
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:240