Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Transforms/IPO/Internalize.h
Line
Count
Source
1
//====- Internalize.h - Internalization API ---------------------*- 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 pass loops over all of the functions and variables in the input module.
10
// If the function or variable does not need to be preserved according to the
11
// client supplied callback, it is marked as internal.
12
//
13
// This transformation would not be legal in a regular compilation, but it gets
14
// extra information from the linker about what is safe.
15
//
16
// For example: Internalizing a function with external linkage. Only if we are
17
// told it is only used from within this module, it is safe to do it.
18
//
19
//===----------------------------------------------------------------------===//
20
21
#ifndef LLVM_TRANSFORMS_IPO_INTERNALIZE_H
22
#define LLVM_TRANSFORMS_IPO_INTERNALIZE_H
23
24
#include "llvm/ADT/DenseSet.h"
25
#include "llvm/ADT/StringSet.h"
26
#include "llvm/IR/GlobalValue.h"
27
#include "llvm/IR/PassManager.h"
28
#include <functional>
29
30
namespace llvm {
31
class Module;
32
class CallGraph;
33
34
/// A pass that internalizes all functions and variables other than those that
35
/// must be preserved according to \c MustPreserveGV.
36
class InternalizePass : public PassInfoMixin<InternalizePass> {
37
  /// Client supplied callback to control wheter a symbol must be preserved.
38
  const std::function<bool(const GlobalValue &)> MustPreserveGV;
39
  /// Set of symbols private to the compiler that this pass should not touch.
40
  StringSet<> AlwaysPreserved;
41
42
  /// Return false if we're allowed to internalize this GV.
43
  bool shouldPreserveGV(const GlobalValue &GV);
44
  /// Internalize GV if it is possible to do so, i.e. it is not externally
45
  /// visible and is not a member of an externally visible comdat.
46
  bool maybeInternalize(GlobalValue &GV,
47
                        const DenseSet<const Comdat *> &ExternalComdats);
48
  /// If GV is part of a comdat and is externally visible, keep track of its
49
  /// comdat so that we don't internalize any of its members.
50
  void checkComdatVisibility(GlobalValue &GV,
51
                             DenseSet<const Comdat *> &ExternalComdats);
52
53
public:
54
  InternalizePass();
55
  InternalizePass(std::function<bool(const GlobalValue &)> MustPreserveGV)
56
422
      : MustPreserveGV(std::move(MustPreserveGV)) {}
57
58
  /// Run the internalizer on \p TheModule, returns true if any changes was
59
  /// made.
60
  ///
61
  /// If the CallGraph \p CG is supplied, it will be updated when
62
  /// internalizing a function (by removing any edge from the "external node")
63
  bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr);
64
65
  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
66
};
67
68
/// Helper function to internalize functions and variables in a Module.
69
inline bool
70
internalizeModule(Module &TheModule,
71
                  std::function<bool(const GlobalValue &)> MustPreserveGV,
72
419
                  CallGraph *CG = nullptr) {
73
419
  return InternalizePass(std::move(MustPreserveGV))
74
419
      .internalizeModule(TheModule, CG);
75
419
}
76
} // end namespace llvm
77
78
#endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H