LLVM  4.0.0
FunctionImportUtils.h
Go to the documentation of this file.
1 //===- FunctionImportUtils.h - Importing support utilities -----*- C++ -*-===//
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 defines the FunctionImportGlobalProcessing class which is used
11 // to perform the necessary global value handling for function importing.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
16 #define LLVM_TRANSFORMS_UTILS_FUNCTIONIMPORTUTILS_H
17 
18 #include "llvm/ADT/SetVector.h"
20 
21 namespace llvm {
22 class Module;
23 
24 /// Class to handle necessary GlobalValue changes required by ThinLTO
25 /// function importing, including linkage changes and any necessary renaming.
27  /// The Module which we are exporting or importing functions from.
28  Module &M;
29 
30  /// Module summary index passed in for function importing/exporting handling.
31  const ModuleSummaryIndex &ImportIndex;
32 
33  /// Globals to import from this module, all other functions will be
34  /// imported as declarations instead of definitions.
35  DenseSet<const GlobalValue *> *GlobalsToImport;
36 
37  /// Set to true if the given ModuleSummaryIndex contains any functions
38  /// from this source module, in which case we must conservatively assume
39  /// that any of its functions may be imported into another module
40  /// as part of a different backend compilation process.
41  bool HasExportedFunctions = false;
42 
43  /// Set of llvm.*used values, in order to validate that we don't try
44  /// to promote any non-renamable values.
46 
47  /// Check if we should promote the given local value to global scope.
48  bool shouldPromoteLocalToGlobal(const GlobalValue *SGV);
49 
50 #ifndef NDEBUG
51  /// Check if the given value is a local that can't be renamed (promoted).
52  /// Only used in assertion checking, and disabled under NDEBUG since the Used
53  /// set will not be populated.
54  bool isNonRenamableLocal(const GlobalValue &GV) const;
55 #endif
56 
57  /// Helper methods to check if we are importing from or potentially
58  /// exporting from the current source module.
59  bool isPerformingImport() const { return GlobalsToImport != nullptr; }
60  bool isModuleExporting() const { return HasExportedFunctions; }
61 
62  /// If we are importing from the source module, checks if we should
63  /// import SGV as a definition, otherwise import as a declaration.
64  bool doImportAsDefinition(const GlobalValue *SGV);
65 
66  /// Get the name for SGV that should be used in the linked destination
67  /// module. Specifically, this handles the case where we need to rename
68  /// a local that is being promoted to global scope, which it will always
69  /// do when \p DoPromote is true (or when importing a local).
70  std::string getName(const GlobalValue *SGV, bool DoPromote);
71 
72  /// Process globals so that they can be used in ThinLTO. This includes
73  /// promoting local variables so that they can be reference externally by
74  /// thin lto imported globals and converting strong external globals to
75  /// available_externally.
76  void processGlobalsForThinLTO();
77  void processGlobalForThinLTO(GlobalValue &GV);
78 
79  /// Get the new linkage for SGV that should be used in the linked destination
80  /// module. Specifically, for ThinLTO importing or exporting it may need
81  /// to be adjusted. When \p DoPromote is true then we must adjust the
82  /// linkage for a required promotion of a local to global scope.
83  GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
84 
85 public:
87  Module &M, const ModuleSummaryIndex &Index,
88  DenseSet<const GlobalValue *> *GlobalsToImport = nullptr)
89  : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
90  // If we have a ModuleSummaryIndex but no function to import,
91  // then this is the primary module being compiled in a ThinLTO
92  // backend compilation, and we need to see if it has functions that
93  // may be exported to another backend compilation.
94  if (!GlobalsToImport)
95  HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
96 
97 #ifndef NDEBUG
98  // First collect those in the llvm.used set.
99  collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
100  // Next collect those in the llvm.compiler.used set.
101  collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
102 #endif
103  }
104 
105  bool run();
106 
107  static bool
108  doImportAsDefinition(const GlobalValue *SGV,
109  DenseSet<const GlobalValue *> *GlobalsToImport);
110 };
111 
112 /// Perform in-place global value handling on the given Module for
113 /// exported local functions renamed and promoted for ThinLTO.
115  Module &M, const ModuleSummaryIndex &Index,
116  DenseSet<const GlobalValue *> *GlobalsToImport = nullptr);
117 
118 } // End llvm namespace
119 
120 #endif
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallPtrSetImpl< GlobalValue * > &Set, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:528
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
FunctionImportGlobalProcessing(Module &M, const ModuleSummaryIndex &Index, DenseSet< const GlobalValue * > *GlobalsToImport=nullptr)
bool hasExportedFunctions(const Module &M) const
Check if the given Module has any functions available for exporting in the index. ...
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
bool renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index, DenseSet< const GlobalValue * > *GlobalsToImport=nullptr)
Perform in-place global value handling on the given Module for exported local functions renamed and p...
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...