Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Transforms/Utils/FunctionImportUtils.h
Line
Count
Source
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
20
namespace llvm {
21
class Module;
22
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.
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);
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
1.95k
  bool isPerformingImport() const { return GlobalsToImport != nullptr; }
64
2.19k
  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 SGV that should be used in the linked destination
71
  /// module. Specifically, this handles the case where we need to rename
72
  /// a local that is being promoted to global scope, which it will always
73
  /// do when \p DoPromote is true (or when importing a local).
74
  std::string getName(const GlobalValue *SGV, bool DoPromote);
75
76
  /// Process globals so that they can be used in ThinLTO. This includes
77
  /// promoting local variables so that they can be reference externally by
78
  /// thin lto imported globals and converting strong external globals to
79
  /// available_externally.
80
  void processGlobalsForThinLTO();
81
  void processGlobalForThinLTO(GlobalValue &GV);
82
83
  /// Get the new linkage for SGV that should be used in the linked destination
84
  /// module. Specifically, for ThinLTO importing or exporting it may need
85
  /// to be adjusted. When \p DoPromote is true then we must adjust the
86
  /// linkage for a required promotion of a local to global scope.
87
  GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
88
89
public:
90
  FunctionImportGlobalProcessing(
91
      Module &M, const ModuleSummaryIndex &Index,
92
      SetVector<GlobalValue *> *GlobalsToImport = nullptr)
93
566
      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
94
566
    // If we have a ModuleSummaryIndex but no function to import,
95
566
    // then this is the primary module being compiled in a ThinLTO
96
566
    // backend compilation, and we need to see if it has functions that
97
566
    // may be exported to another backend compilation.
98
566
    if (!GlobalsToImport)
99
412
      HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
100
566
101
#ifndef NDEBUG
102
    // First collect those in the llvm.used set.
103
    collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
104
    // Next collect those in the llvm.compiler.used set.
105
    collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
106
#endif
107
  }
108
109
  bool run();
110
111
  static bool doImportAsDefinition(const GlobalValue *SGV,
112
                                   SetVector<GlobalValue *> *GlobalsToImport);
113
};
114
115
/// Perform in-place global value handling on the given Module for
116
/// exported local functions renamed and promoted for ThinLTO.
117
bool renameModuleForThinLTO(
118
    Module &M, const ModuleSummaryIndex &Index,
119
    SetVector<GlobalValue *> *GlobalsToImport = nullptr);
120
121
/// Compute synthetic function entry counts.
122
void computeSyntheticCounts(ModuleSummaryIndex &Index);
123
124
} // End llvm namespace
125
126
#endif