clang  10.0.0svn
Linkage.h
Go to the documentation of this file.
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).
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.
41 
42  /// No linkage according to the standard, but is visible from other
43  /// translation units because of types defined in a inline function.
45 
46  /// Internal linkage according to the Modules TS, but can be referred
47  /// to from other translation units indirectly through inline functions and
48  /// templates in the module interface.
50 
51  /// Module linkage, which indicates that the entity can be referred
52  /// to from other translation units within the same module, and indirectly
53  /// from arbitrary other translation units through inline functions and
54  /// templates in the module interface.
56 
57  /// External linkage, which indicates that the entity can
58  /// be referred to from other translation units.
60 };
61 
62 /// Describes the different kinds of language linkage
63 /// (C++ [dcl.link]) that an entity may have.
68 };
69 
70 /// A more specific kind of linkage than enum Linkage.
71 ///
72 /// This is relevant to CodeGen and AST file reading.
73 enum GVALinkage {
79 };
80 
82  return L <= GVA_DiscardableODR;
83 }
84 
85 /// Do we know that this will be the only definition of this symbol (excluding
86 /// inlining-only definitions)?
88  return L == GVA_Internal || L == GVA_StrongExternal;
89 }
90 
91 inline bool isExternallyVisible(Linkage L) {
92  return L >= VisibleNoLinkage;
93 }
94 
96  switch (L) {
98  return ExternalLinkage;
99  case VisibleNoLinkage:
100  return NoLinkage;
102  return InternalLinkage;
103  default:
104  return L;
105  }
106 }
107 
109  return getFormalLinkage(L) == ExternalLinkage;
110 }
111 
112 /// Compute the minimum linkage given two linkages.
113 ///
114 /// The linkage can be interpreted as a pair formed by the formal linkage and
115 /// a boolean for external visibility. This is just what getFormalLinkage and
116 /// isExternallyVisible return. We want the minimum of both components. The
117 /// Linkage enum is defined in an order that makes this simple, we just need
118 /// special cases for when VisibleNoLinkage would lose the visible bit and
119 /// become NoLinkage.
121  if (L2 == VisibleNoLinkage)
122  std::swap(L1, L2);
123  if (L1 == VisibleNoLinkage) {
124  if (L2 == InternalLinkage)
125  return NoLinkage;
126  if (L2 == UniqueExternalLinkage)
127  return NoLinkage;
128  }
129  return L1 < L2 ? L1 : L2;
130 }
131 
132 } // namespace clang
133 
134 #endif // LLVM_CLANG_BASIC_LINKAGE_H
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:59
Internal linkage according to the Modules TS, but can be referred to from other translation units ind...
Definition: Linkage.h:49
No linkage, which means that the entity is unique and can only be referred to from within its scope...
Definition: Linkage.h:26
bool isDiscardableGVALinkage(GVALinkage L)
Definition: Linkage.h:81
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:23
Linkage getFormalLinkage(Linkage L)
Definition: Linkage.h:95
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:108
Module linkage, which indicates that the entity can be referred to from other translation units withi...
Definition: Linkage.h:55
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:91
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:64
Linkage minLinkage(Linkage L1, Linkage L2)
Compute the minimum linkage given two linkages.
Definition: Linkage.h:120
bool isUniqueGVALinkage(GVALinkage L)
Do we know that this will be the only definition of this symbol (excluding inlining-only definitions)...
Definition: Linkage.h:87
Dataflow Directional Tag Classes.
External linkage within a unique namespace.
Definition: Linkage.h:40
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
No linkage according to the standard, but is visible from other translation units because of types de...
Definition: Linkage.h:44
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:73