Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Basic/Visibility.h
Line
Count
Source (jump to first uncovered line)
1
//===--- Visibility.h - Visibility enumeration and 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
/// \file
10
/// Defines the clang::Visibility enumeration and various utility
11
/// functions.
12
///
13
//===----------------------------------------------------------------------===//
14
#ifndef LLVM_CLANG_BASIC_VISIBILITY_H
15
#define LLVM_CLANG_BASIC_VISIBILITY_H
16
17
#include "clang/Basic/Linkage.h"
18
#include <cassert>
19
#include <cstdint>
20
21
namespace clang {
22
23
/// Describes the different kinds of visibility that a declaration
24
/// may have.
25
///
26
/// Visibility determines how a declaration interacts with the dynamic
27
/// linker.  It may also affect whether the symbol can be found by runtime
28
/// symbol lookup APIs.
29
///
30
/// Visibility is not described in any language standard and
31
/// (nonetheless) sometimes has odd behavior.  Not all platforms
32
/// support all visibility kinds.
33
enum Visibility {
34
  /// Objects with "hidden" visibility are not seen by the dynamic
35
  /// linker.
36
  HiddenVisibility,
37
38
  /// Objects with "protected" visibility are seen by the dynamic
39
  /// linker but always dynamically resolve to an object within this
40
  /// shared object.
41
  ProtectedVisibility,
42
43
  /// Objects with "default" visibility are seen by the dynamic linker
44
  /// and act like normal objects.
45
  DefaultVisibility
46
};
47
48
0
inline Visibility minVisibility(Visibility L, Visibility R) {
49
0
  return L < R ? L : R;
50
0
}
51
52
class LinkageInfo {
53
  uint8_t linkage_    : 3;
54
  uint8_t visibility_ : 2;
55
  uint8_t explicit_   : 1;
56
57
4.00M
  void setVisibility(Visibility V, bool E) { visibility_ = V; explicit_ = E; }
58
public:
59
  LinkageInfo() : linkage_(ExternalLinkage), visibility_(DefaultVisibility),
60
26.3M
                  explicit_(false) {}
61
  LinkageInfo(Linkage L, Visibility V, bool E)
62
52.8M
    : linkage_(L), visibility_(V), explicit_(E) {
63
52.8M
    assert(getLinkage() == L && getVisibility() == V &&
64
52.8M
           isVisibilityExplicit() == E && "Enum truncated!");
65
52.8M
  }
66
67
8.38M
  static LinkageInfo external() {
68
8.38M
    return LinkageInfo();
69
8.38M
  }
70
1.35M
  static LinkageInfo internal() {
71
1.35M
    return LinkageInfo(InternalLinkage, DefaultVisibility, false);
72
1.35M
  }
73
2.49k
  static LinkageInfo uniqueExternal() {
74
2.49k
    return LinkageInfo(UniqueExternalLinkage, DefaultVisibility, false);
75
2.49k
  }
76
1.55M
  static LinkageInfo none() {
77
1.55M
    return LinkageInfo(NoLinkage, DefaultVisibility, false);
78
1.55M
  }
79
1
  static LinkageInfo visible_none() {
80
1
    return LinkageInfo(VisibleNoLinkage, DefaultVisibility, false);
81
1
  }
82
83
96.6M
  Linkage getLinkage() const { return (Linkage)linkage_; }
84
20.7M
  Visibility getVisibility() const { return (Visibility)visibility_; }
85
15.5M
  bool isVisibilityExplicit() const { return explicit_; }
86
87
9.25M
  void setLinkage(Linkage L) { linkage_ = L; }
88
89
7.50M
  void mergeLinkage(Linkage L) {
90
7.50M
    setLinkage(minLinkage(getLinkage(), L));
91
7.50M
  }
92
7.50M
  void mergeLinkage(LinkageInfo other) {
93
7.50M
    mergeLinkage(other.getLinkage());
94
7.50M
  }
95
96
1.75M
  void mergeExternalVisibility(Linkage L) {
97
1.75M
    Linkage ThisL = getLinkage();
98
1.75M
    if (!isExternallyVisible(L)) {
99
2.39k
      if (ThisL == VisibleNoLinkage)
100
0
        ThisL = NoLinkage;
101
2.39k
      else if (ThisL == ExternalLinkage)
102
2.39k
        ThisL = UniqueExternalLinkage;
103
2.39k
    }
104
1.75M
    setLinkage(ThisL);
105
1.75M
  }
106
1.75M
  void mergeExternalVisibility(LinkageInfo Other) {
107
1.75M
    mergeExternalVisibility(Other.getLinkage());
108
1.75M
  }
109
110
  /// Merge in the visibility 'newVis'.
111
11.5M
  void mergeVisibility(Visibility newVis, bool newExplicit) {
112
11.5M
    Visibility oldVis = getVisibility();
113
11.5M
114
11.5M
    // Never increase visibility.
115
11.5M
    if (oldVis < newVis)
116
621k
      return;
117
10.8M
118
10.8M
    // If the new visibility is the same as the old and the new
119
10.8M
    // visibility isn't explicit, we have nothing to add.
120
10.8M
    if (oldVis == newVis && 
!newExplicit9.47M
)
121
6.87M
      return;
122
4.00M
123
4.00M
    // Otherwise, we're either decreasing visibility or making our
124
4.00M
    // existing visibility explicit.
125
4.00M
    setVisibility(newVis, newExplicit);
126
4.00M
  }
127
8.66M
  void mergeVisibility(LinkageInfo other) {
128
8.66M
    mergeVisibility(other.getVisibility(), other.isVisibilityExplicit());
129
8.66M
  }
130
131
  /// Merge both linkage and visibility.
132
3.29M
  void merge(LinkageInfo other) {
133
3.29M
    mergeLinkage(other);
134
3.29M
    mergeVisibility(other);
135
3.29M
  }
136
137
  /// Merge linkage and conditionally merge visibility.
138
4.21M
  void mergeMaybeWithVisibility(LinkageInfo other, bool withVis) {
139
4.21M
    mergeLinkage(other);
140
4.21M
    if (withVis) 
mergeVisibility(other)3.67M
;
141
4.21M
  }
142
};
143
}
144
145
#endif // LLVM_CLANG_BASIC_VISIBILITY_H