Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Transforms/IPO/FunctionImport.h
Line
Count
Source
1
//===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- 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
#ifndef LLVM_FUNCTIONIMPORT_H
11
#define LLVM_FUNCTIONIMPORT_H
12
13
#include "llvm/ADT/StringMap.h"
14
#include "llvm/IR/GlobalValue.h"
15
#include "llvm/IR/ModuleSummaryIndex.h"
16
#include "llvm/IR/PassManager.h"
17
#include "llvm/Support/Error.h"
18
19
#include <functional>
20
#include <map>
21
#include <unordered_set>
22
#include <utility>
23
24
namespace llvm {
25
class LLVMContext;
26
class GlobalValueSummary;
27
class Module;
28
29
/// The function importer is automatically importing function from other modules
30
/// based on the provided summary informations.
31
class FunctionImporter {
32
public:
33
  /// Set of functions to import from a source module. Each entry is a map
34
  /// containing all the functions to import for a source module.
35
  /// The keys is the GUID identifying a function to import, and the value
36
  /// is the threshold applied when deciding to import it.
37
  typedef std::map<GlobalValue::GUID, unsigned> FunctionsToImportTy;
38
39
  /// The map contains an entry for every module to import from, the key being
40
  /// the module identifier to pass to the ModuleLoader. The value is the set of
41
  /// functions to import.
42
  typedef StringMap<FunctionsToImportTy> ImportMapTy;
43
44
  /// The set contains an entry for every global value the module exports.
45
  typedef std::unordered_set<GlobalValue::GUID> ExportSetTy;
46
47
  /// A function of this type is used to load modules referenced by the index.
48
  typedef std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>
49
      ModuleLoaderTy;
50
51
  /// Create a Function Importer.
52
  FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader)
53
217
      : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
54
55
  /// Import functions in Module \p M based on the supplied import list.
56
  Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
57
58
private:
59
  /// The summaries index used to trigger importing.
60
  const ModuleSummaryIndex &Index;
61
62
  /// Factory function to load a Module for a given identifier
63
  ModuleLoaderTy ModuleLoader;
64
};
65
66
/// The function importing pass
67
class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
68
public:
69
  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
70
};
71
72
/// Compute all the imports and exports for every module in the Index.
73
///
74
/// \p ModuleToDefinedGVSummaries contains for each Module a map
75
/// (GUID -> Summary) for every global defined in the module.
76
///
77
/// \p ImportLists will be populated with an entry for every Module we are
78
/// importing into. This entry is itself a map that can be passed to
79
/// FunctionImporter::importFunctions() above (see description there).
80
///
81
/// \p ExportLists contains for each Module the set of globals (GUID) that will
82
/// be imported by another module, or referenced by such a function. I.e. this
83
/// is the set of globals that need to be promoted/renamed appropriately.
84
void ComputeCrossModuleImport(
85
    const ModuleSummaryIndex &Index,
86
    const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
87
    StringMap<FunctionImporter::ImportMapTy> &ImportLists,
88
    StringMap<FunctionImporter::ExportSetTy> &ExportLists);
89
90
/// Compute all the imports for the given module using the Index.
91
///
92
/// \p ImportList will be populated with a map that can be passed to
93
/// FunctionImporter::importFunctions() above (see description there).
94
void ComputeCrossModuleImportForModule(
95
    StringRef ModulePath, const ModuleSummaryIndex &Index,
96
    FunctionImporter::ImportMapTy &ImportList);
97
98
/// Compute all the symbols that are "dead": i.e these that can't be reached
99
/// in the graph from any of the given symbols listed in
100
/// \p GUIDPreservedSymbols.
101
void computeDeadSymbols(
102
    ModuleSummaryIndex &Index,
103
    const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols);
104
105
/// Compute the set of summaries needed for a ThinLTO backend compilation of
106
/// \p ModulePath.
107
//
108
/// This includes summaries from that module (in case any global summary based
109
/// optimizations were recorded) and from any definitions in other modules that
110
/// should be imported.
111
//
112
/// \p ModuleToSummariesForIndex will be populated with the needed summaries
113
/// from each required module path. Use a std::map instead of StringMap to get
114
/// stable order for bitcode emission.
115
void gatherImportedSummariesForModule(
116
    StringRef ModulePath,
117
    const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
118
    const FunctionImporter::ImportMapTy &ImportList,
119
    std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
120
121
/// Emit into \p OutputFilename the files module \p ModulePath will import from.
122
std::error_code
123
EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename,
124
                 const FunctionImporter::ImportMapTy &ModuleImports);
125
126
/// Resolve WeakForLinker values in \p TheModule based on the information
127
/// recorded in the summaries during global summary-based analysis.
128
void thinLTOResolveWeakForLinkerModule(Module &TheModule,
129
                                       const GVSummaryMapTy &DefinedGlobals);
130
131
/// Internalize \p TheModule based on the information recorded in the summaries
132
/// during global summary-based analysis.
133
void thinLTOInternalizeModule(Module &TheModule,
134
                              const GVSummaryMapTy &DefinedGlobals);
135
}
136
137
#endif // LLVM_FUNCTIONIMPORT_H