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 /// Do we know that this will be the only definition of this symbol (excluding 86 /// inlining-only definitions)? 87 inline bool isUniqueGVALinkage(GVALinkage L) { 88 return L == GVA_Internal || L == GVA_StrongExternal; 89 } 90 91 inline bool isExternallyVisible(Linkage L) { 92 return L >= VisibleNoLinkage; 93 } 94 95 inline 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 108 inline 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. 120 inline 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