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