| 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 | /// 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. |
| 64 | enum 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. |
| 73 | enum GVALinkage { |
| 74 | GVA_Internal, |
| 75 | GVA_AvailableExternally, |
| 76 | GVA_DiscardableODR, |
| 77 | GVA_StrongExternal, |
| 78 | GVA_StrongODR |
| 79 | }; |
| 80 | |
| 81 | inline bool isDiscardableGVALinkage(GVALinkage L) { |
| 82 | return L <= GVA_DiscardableODR; |
| 83 | } |
| 84 | |
| 85 | inline bool isExternallyVisible(Linkage L) { |
| 86 | return L >= VisibleNoLinkage; |
| 87 | } |
| 88 | |
| 89 | inline Linkage getFormalLinkage(Linkage L) { |
| 90 | switch (L) { |
| 91 | case UniqueExternalLinkage: |
| 92 | return ExternalLinkage; |
| 93 | case VisibleNoLinkage: |
| 94 | return NoLinkage; |
| 95 | case ModuleInternalLinkage: |
| 96 | return InternalLinkage; |
| 97 | default: |
| 98 | return L; |
| 99 | } |
| 100 | } |
| 101 | |
| 102 | inline bool isExternalFormalLinkage(Linkage L) { |
| 103 | return getFormalLinkage(L) == ExternalLinkage; |
| 104 | } |
| 105 | |
| 106 | /// Compute the minimum linkage given two linkages. |
| 107 | /// |
| 108 | /// The linkage can be interpreted as a pair formed by the formal linkage and |
| 109 | /// a boolean for external visibility. This is just what getFormalLinkage and |
| 110 | /// isExternallyVisible return. We want the minimum of both components. The |
| 111 | /// Linkage enum is defined in an order that makes this simple, we just need |
| 112 | /// special cases for when VisibleNoLinkage would lose the visible bit and |
| 113 | /// become NoLinkage. |
| 114 | inline Linkage minLinkage(Linkage L1, Linkage L2) { |
| 115 | if (L2 == VisibleNoLinkage) |
| 116 | std::swap(L1, L2); |
| 117 | if (L1 == VisibleNoLinkage) { |
| 118 | if (L2 == InternalLinkage) |
| 119 | return NoLinkage; |
| 120 | if (L2 == UniqueExternalLinkage) |
| 121 | return NoLinkage; |
| 122 | } |
| 123 | return L1 < L2 ? L1 : L2; |
| 124 | } |
| 125 | |
| 126 | } // namespace clang |
| 127 | |
| 128 | #endif // LLVM_CLANG_BASIC_LINKAGE_H |
| 129 |