Warning: That file was not part of the compilation database. It may have many parsing errors.
1 | //===- Linkage.h - Linkage 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 Linkage enumeration and various utility functions. |
12 | // |
13 | //===----------------------------------------------------------------------===// |
14 | |
15 | #ifndef LLVM_CLANG_BASIC_LINKAGE_H |
16 | #define LLVM_CLANG_BASIC_LINKAGE_H |
17 | |
18 | #include <utility> |
19 | |
20 | namespace clang { |
21 | |
22 | /// Describes the different kinds of linkage |
23 | /// (C++ [basic.link], C99 6.2.2) that an entity may have. |
24 | enum Linkage : unsigned char { |
25 | /// No linkage, which means that the entity is unique and |
26 | /// can only be referred to from within its scope. |
27 | NoLinkage = 0, |
28 | |
29 | /// Internal linkage, which indicates that the entity can |
30 | /// be referred to from within the translation unit (but not other |
31 | /// translation units). |
32 | InternalLinkage, |
33 | |
34 | /// External linkage within a unique namespace. |
35 | /// |
36 | /// From the language perspective, these entities have external |
37 | /// linkage. However, since they reside in an anonymous namespace, |
38 | /// their names are unique to this translation unit, which is |
39 | /// equivalent to having internal linkage from the code-generation |
40 | /// point of view. |
41 | UniqueExternalLinkage, |
42 | |
43 | /// No linkage according to the standard, but is visible from other |
44 | /// translation units because of types defined in a inline function. |
45 | VisibleNoLinkage, |
46 | |
47 | /// Internal linkage according to the Modules TS, but can be referred |
48 | /// to from other translation units indirectly through inline functions and |
49 | /// templates in the module interface. |
50 | ModuleInternalLinkage, |
51 | |
52 | /// Module linkage, which indicates that the entity can be referred |
53 | /// to from other translation units within the same module, and indirectly |
54 | /// from arbitrary other translation units through inline functions and |
55 | /// templates in the module interface. |
56 | ModuleLinkage, |
57 | |
58 | /// External linkage, which indicates that the entity can |
59 | /// be referred to from other translation units. |
60 | ExternalLinkage |
61 | }; |
62 | |
63 | /// Describes the different kinds of language linkage |
64 | /// (C++ [dcl.link]) that an entity may have. |
65 | enum LanguageLinkage { |
66 | CLanguageLinkage, |
67 | CXXLanguageLinkage, |
68 | NoLanguageLinkage |
69 | }; |
70 | |
71 | /// A more specific kind of linkage than enum Linkage. |
72 | /// |
73 | /// This is relevant to CodeGen and AST file reading. |
74 | enum GVALinkage { |
75 | GVA_Internal, |
76 | GVA_AvailableExternally, |
77 | GVA_DiscardableODR, |
78 | GVA_StrongExternal, |
79 | GVA_StrongODR |
80 | }; |
81 | |
82 | inline bool isDiscardableGVALinkage(GVALinkage L) { |
83 | return L <= GVA_DiscardableODR; |
84 | } |
85 | |
86 | inline bool isExternallyVisible(Linkage L) { |
87 | return L >= VisibleNoLinkage; |
88 | } |
89 | |
90 | inline Linkage getFormalLinkage(Linkage L) { |
91 | switch (L) { |
92 | case UniqueExternalLinkage: |
93 | return ExternalLinkage; |
94 | case VisibleNoLinkage: |
95 | return NoLinkage; |
96 | case ModuleInternalLinkage: |
97 | return InternalLinkage; |
98 | default: |
99 | return L; |
100 | } |
101 | } |
102 | |
103 | inline bool isExternalFormalLinkage(Linkage L) { |
104 | return getFormalLinkage(L) == ExternalLinkage; |
105 | } |
106 | |
107 | /// Compute the minimum linkage given two linkages. |
108 | /// |
109 | /// The linkage can be interpreted as a pair formed by the formal linkage and |
110 | /// a boolean for external visibility. This is just what getFormalLinkage and |
111 | /// isExternallyVisible return. We want the minimum of both components. The |
112 | /// Linkage enum is defined in an order that makes this simple, we just need |
113 | /// special cases for when VisibleNoLinkage would lose the visible bit and |
114 | /// become NoLinkage. |
115 | inline Linkage minLinkage(Linkage L1, Linkage L2) { |
116 | if (L2 == VisibleNoLinkage) |
117 | std::swap(L1, L2); |
118 | if (L1 == VisibleNoLinkage) { |
119 | if (L2 == InternalLinkage) |
120 | return NoLinkage; |
121 | if (L2 == UniqueExternalLinkage) |
122 | return NoLinkage; |
123 | } |
124 | return L1 < L2 ? L1 : L2; |
125 | } |
126 | |
127 | } // namespace clang |
128 | |
129 | #endif // LLVM_CLANG_BASIC_LINKAGE_H |
130 |
Warning: That file was not part of the compilation database. It may have many parsing errors.