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