LLVM  6.0.0svn
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  SetVector<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  SetVector<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 doImportAsDefinition(const GlobalValue *SGV,
108  SetVector<GlobalValue *> *GlobalsToImport);
109 };
110 
111 /// Perform in-place global value handling on the given Module for
112 /// exported local functions renamed and promoted for ThinLTO.
114  Module &M, const ModuleSummaryIndex &Index,
115  SetVector<GlobalValue *> *GlobalsToImport = nullptr);
116 
117 } // End llvm namespace
118 
119 #endif
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming.
bool hasExportedFunctions(const Module &M) const
Check if the given Module has any functions available for exporting in the index. ...
Class to hold module path string table and global value map, and encapsulate methods for operating on...
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...
FunctionImportGlobalProcessing(Module &M, const ModuleSummaryIndex &Index, SetVector< GlobalValue *> *GlobalsToImport=nullptr)
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:513
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
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...
A vector that has set insertion semantics.
Definition: SetVector.h:41