contrib/llvm-project/clang/include/clang/Basic/Linkage.h

   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