FunctionImportUtils.h revision 360784 
1//===- FunctionImportUtils.h - Importing support utilities -----*- C++ -*-===//
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 defines the FunctionImportGlobalProcessing class which is used
10// to perform the necessary global value handling for function importing.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
15#define LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
16
17#include "llvm/ADT/SetVector.h"
18#include "llvm/IR/ModuleSummaryIndex.h"
19
20namespace llvm {
21class Module;
22
23/// Class to handle necessary GlobalValue changes required by ThinLTO
24/// function importing, including linkage changes and any necessary renaming.
25class FunctionImportGlobalProcessing {
26  /// The Module which we are exporting or importing functions from.
27  Module &M;
28
29  /// Module summary index passed in for function importing/exporting handling.
30  const ModuleSummaryIndex &ImportIndex;
31
32  /// Globals to import from this module, all other functions will be
33  /// imported as declarations instead of definitions.
34  SetVector<GlobalValue *> *GlobalsToImport;
35
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;
41
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;
45
46  /// Keep track of any COMDATs that require renaming (because COMDAT
47  /// leader was promoted and renamed). Maps from original COMDAT to one
48  /// with new name.
49  DenseMap<const Comdat *, Comdat *> RenamedComdats;
50
51  /// Check if we should promote the given local value to global scope.
52  bool shouldPromoteLocalToGlobal(const GlobalValue *SGV, ValueInfo VI);
53
54#ifndef NDEBUG
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;
59#endif
60
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; }
65
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);
69
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);
73
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);
80
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);
86
87public:
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.
96    if (!GlobalsToImport)
97      HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
98
99#ifndef NDEBUG
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);
104#endif
105  }
106
107  bool run();
108};
109
110/// Perform in-place global value handling on the given Module for
111/// exported local functions renamed and promoted for ThinLTO.
112bool renameModuleForThinLTO(
113    Module &M, const ModuleSummaryIndex &Index,
114    SetVector<GlobalValue *> *GlobalsToImport = nullptr);
115
116/// Compute synthetic function entry counts.
117void computeSyntheticCounts(ModuleSummaryIndex &Index);
118
119} // End llvm namespace
120
121#endif
122