Coverage Report

Created: 2019-02-21 13:17

/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
inline Visibility minVisibility(Visibility L, Visibility R) {
49
  return L < R ? L : R;
50
}
51
52
class LinkageInfo {
53
  uint8_t linkage_    : 3;
54
  uint8_t visibility_ : 2;
55
  uint8_t explicit_   : 1;
56
57
3.72M
  void setVisibility(Visibility V, bool E) { visibility_ = V; explicit_ = E; }
58
public:
59
  LinkageInfo() : linkage_(ExternalLinkage), visibility_(DefaultVisibility),
60
24.7M
                  explicit_(false) {}
61
  LinkageInfo(Linkage L, Visibility V, bool E)
62
49.8M
    : linkage_(L), visibility_(V), explicit_(E) {
63
49.8M
    assert(getLinkage() == L && getVisibility() == V &&
64
49.8M
           isVisibilityExplicit() == E && "Enum truncated!");
65
49.8M
  }
66
67
7.89M
  static LinkageInfo external() {
68
7.89M
    return LinkageInfo();
69
7.89M
  }
70
1.21M
  static LinkageInfo internal() {
71
1.21M
    return LinkageInfo(InternalLinkage, DefaultVisibility, false);
72
1.21M
  }
73
2.41k
  static LinkageInfo uniqueExternal() {
74
2.41k
    return LinkageInfo(UniqueExternalLinkage, DefaultVisibility, false);
75
2.41k
  }
76
1.47M
  static LinkageInfo none() {
77
1.47M
    return LinkageInfo(NoLinkage, DefaultVisibility, false);
78
1.47M
  }
79
1
  static LinkageInfo visible_none() {
80
1
    return LinkageInfo(VisibleNoLinkage, DefaultVisibility, false);
81
1
  }
82
83
91.1M
  Linkage getLinkage() const { return (Linkage)linkage_; }
84
19.6M
  Visibility getVisibility() const { return (Visibility)visibility_; }
85
14.7M
  bool isVisibilityExplicit() const { return explicit_; }
86
87
8.74M
  void setLinkage(Linkage L) { linkage_ = L; }
88
89
7.10M
  void mergeLinkage(Linkage L) {
90
7.10M
    setLinkage(minLinkage(getLinkage(), L));
91
7.10M
  }
92
7.10M
  void mergeLinkage(LinkageInfo other) {
93
7.10M
    mergeLinkage(other.getLinkage());
94
7.10M
  }
95
96
1.63M
  void mergeExternalVisibility(Linkage L) {
97
1.63M
    Linkage ThisL = getLinkage();
98
1.63M
    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.63M
    setLinkage(ThisL);
105
1.63M
  }
106
1.63M
  void mergeExternalVisibility(LinkageInfo Other) {
107
1.63M
    mergeExternalVisibility(Other.getLinkage());
108
1.63M
  }
109
110
  /// Merge in the visibility 'newVis'.
111
10.9M
  void mergeVisibility(Visibility newVis, bool newExplicit) {
112
10.9M
    Visibility oldVis = getVisibility();
113
10.9M
114
10.9M
    // Never increase visibility.
115
10.9M
    if (oldVis < newVis)
116
565k
      return;
117
10.3M
118
10.3M
    // If the new visibility is the same as the old and the new
119
10.3M
    // visibility isn't explicit, we have nothing to add.
120
10.3M
    if (oldVis == newVis && 
!newExplicit9.07M
)
121
6.64M
      return;
122
3.72M
123
3.72M
    // Otherwise, we're either decreasing visibility or making our
124
3.72M
    // existing visibility explicit.
125
3.72M
    setVisibility(newVis, newExplicit);
126
3.72M
  }
127
8.20M
  void mergeVisibility(LinkageInfo other) {
128
8.20M
    mergeVisibility(other.getVisibility(), other.isVisibilityExplicit());
129
8.20M
  }
130
131
  /// Merge both linkage and visibility.
132
3.11M
  void merge(LinkageInfo other) {
133
3.11M
    mergeLinkage(other);
134
3.11M
    mergeVisibility(other);
135
3.11M
  }
136
137
  /// Merge linkage and conditionally merge visibility.
138
3.99M
  void mergeMaybeWithVisibility(LinkageInfo other, bool withVis) {
139
3.99M
    mergeLinkage(other);
140
3.99M
    if (withVis) 
mergeVisibility(other)3.50M
;
141
3.99M
  }
142
};
143
}
144
145
#endif // LLVM_CLANG_BASIC_VISIBILITY_H