1 //===- FunctionImportUtils.h - Importing support utilities -----*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines the FunctionImportGlobalProcessing class which is used
10 // to perform the necessary global value handling for function importing.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
15 #define LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
17 #include "llvm/ADT/SetVector.h"
18 #include "llvm/IR/ModuleSummaryIndex.h"
23 /// Class to handle necessary GlobalValue changes required by ThinLTO
24 /// function importing, including linkage changes and any necessary renaming.
25 class FunctionImportGlobalProcessing {
26 /// The Module which we are exporting or importing functions from.
29 /// Module summary index passed in for function importing/exporting handling.
30 const ModuleSummaryIndex &ImportIndex;
32 /// Globals to import from this module, all other functions will be
33 /// imported as declarations instead of definitions.
34 SetVector<GlobalValue *> *GlobalsToImport;
36 /// Set to true if the given ModuleSummaryIndex contains any functions
37 /// from this source module, in which case we must conservatively assume
38 /// that any of its functions may be imported into another module
39 /// as part of a different backend compilation process.
40 bool HasExportedFunctions = false;
42 /// Set of llvm.*used values, in order to validate that we don't try
43 /// to promote any non-renamable values.
44 SmallPtrSet<GlobalValue *, 8> Used;
46 /// Keep track of any COMDATs that require renaming (because COMDAT
47 /// leader was promoted and renamed). Maps from original COMDAT to one
49 DenseMap<const Comdat *, Comdat *> RenamedComdats;
51 /// Check if we should promote the given local value to global scope.
52 bool shouldPromoteLocalToGlobal(const GlobalValue *SGV, ValueInfo VI);
55 /// Check if the given value is a local that can't be renamed (promoted).
56 /// Only used in assertion checking, and disabled under NDEBUG since the Used
57 /// set will not be populated.
58 bool isNonRenamableLocal(const GlobalValue &GV) const;
61 /// Helper methods to check if we are importing from or potentially
62 /// exporting from the current source module.
63 bool isPerformingImport() const { return GlobalsToImport != nullptr; }
64 bool isModuleExporting() const { return HasExportedFunctions; }
66 /// If we are importing from the source module, checks if we should
67 /// import SGV as a definition, otherwise import as a declaration.
68 bool doImportAsDefinition(const GlobalValue *SGV);
70 /// Get the name for a local SGV that should be promoted and renamed to global
71 /// scope in the linked destination module.
72 std::string getPromotedName(const GlobalValue *SGV);
74 /// Process globals so that they can be used in ThinLTO. This includes
75 /// promoting local variables so that they can be reference externally by
76 /// thin lto imported globals and converting strong external globals to
77 /// available_externally.
78 void processGlobalsForThinLTO();
79 void processGlobalForThinLTO(GlobalValue &GV);
81 /// Get the new linkage for SGV that should be used in the linked destination
82 /// module. Specifically, for ThinLTO importing or exporting it may need
83 /// to be adjusted. When \p DoPromote is true then we must adjust the
84 /// linkage for a required promotion of a local to global scope.
85 GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
88 FunctionImportGlobalProcessing(
89 Module &M, const ModuleSummaryIndex &Index,
90 SetVector<GlobalValue *> *GlobalsToImport = nullptr)
91 : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
92 // If we have a ModuleSummaryIndex but no function to import,
93 // then this is the primary module being compiled in a ThinLTO
94 // backend compilation, and we need to see if it has functions that
95 // may be exported to another backend compilation.
97 HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
100 // First collect those in the llvm.used set.
101 collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
102 // Next collect those in the llvm.compiler.used set.
103 collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
110 /// Perform in-place global value handling on the given Module for
111 /// exported local functions renamed and promoted for ThinLTO.
112 bool renameModuleForThinLTO(
113 Module &M, const ModuleSummaryIndex &Index,
114 SetVector<GlobalValue *> *GlobalsToImport = nullptr);
116 /// Compute synthetic function entry counts.
117 void computeSyntheticCounts(ModuleSummaryIndex &Index);
119 } // End llvm namespace