Linkage.h revision 360784 
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
19namespace clang {
20
21/// Describes the different kinds of linkage
22/// (C++ [basic.link], C99 6.2.2) that an entity may have.
23enum 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  /// 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.
49  ModuleInternalLinkage,
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.
55  ModuleLinkage,
56
57  /// External linkage, which indicates that the entity can
58  /// be referred to from other translation units.
59  ExternalLinkage
60};
61
62/// Describes the different kinds of language linkage
63/// (C++ [dcl.link]) that an entity may have.
64enum LanguageLinkage {
65  CLanguageLinkage,
66  CXXLanguageLinkage,
67  NoLanguageLinkage
68};
69
70/// A more specific kind of linkage than enum Linkage.
71///
72/// This is relevant to CodeGen and AST file reading.
73enum GVALinkage {
74  GVA_Internal,
75  GVA_AvailableExternally,
76  GVA_DiscardableODR,
77  GVA_StrongExternal,
78  GVA_StrongODR
79};
80
81inline bool isDiscardableGVALinkage(GVALinkage L) {
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)?
87inline bool isUniqueGVALinkage(GVALinkage L) {
88  return L == GVA_Internal || L == GVA_StrongExternal;
89}
90
91inline bool isExternallyVisible(Linkage L) {
92  return L >= VisibleNoLinkage;
93}
94
95inline Linkage getFormalLinkage(Linkage L) {
96  switch (L) {
97  case UniqueExternalLinkage:
98    return ExternalLinkage;
99  case VisibleNoLinkage:
100    return NoLinkage;
101  case ModuleInternalLinkage:
102    return InternalLinkage;
103  default:
104    return L;
105  }
106}
107
108inline bool isExternalFormalLinkage(Linkage L) {
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.
120inline Linkage minLinkage(Linkage L1, Linkage L2) {
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
135