contrib/llvm/tools/clang/include/clang/Basic/Linkage.h

   1 //===- Linkage.h - Linkage enumeration and utilities ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// \file
  11 /// Defines the Linkage enumeration and various utility functions.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_BASIC_LINKAGE_H
  16 #define LLVM_CLANG_BASIC_LINKAGE_H
  17
  18 #include <utility>
  19
  20 namespace clang {
  21
  22 /// Describes the different kinds of linkage
  23 /// (C++ [basic.link], C99 6.2.2) that an entity may have.
  24 enum Linkage : unsigned char {
  25   /// No linkage, which means that the entity is unique and
  26   /// can only be referred to from within its scope.
  27   NoLinkage = 0,
  28
  29   /// Internal linkage, which indicates that the entity can
  30   /// be referred to from within the translation unit (but not other
  31   /// translation units).
  32   InternalLinkage,
  33
  34   /// External linkage within a unique namespace.
  35   ///
  36   /// From the language perspective, these entities have external
  37   /// linkage. However, since they reside in an anonymous namespace,
  38   /// their names are unique to this translation unit, which is
  39   /// equivalent to having internal linkage from the code-generation
  40   /// point of view.
  41   UniqueExternalLinkage,
  42
  43   /// No linkage according to the standard, but is visible from other
  44   /// translation units because of types defined in a inline function.
  45   VisibleNoLinkage,
  46
  47   /// Internal linkage according to the Modules TS, but can be referred
  48   /// to from other translation units indirectly through inline functions and
  49   /// templates in the module interface.
  50   ModuleInternalLinkage,
  51
  52   /// Module linkage, which indicates that the entity can be referred
  53   /// to from other translation units within the same module, and indirectly
  54   /// from arbitrary other translation units through inline functions and
  55   /// templates in the module interface.
  56   ModuleLinkage,
  57
  58   /// External linkage, which indicates that the entity can
  59   /// be referred to from other translation units.
  60   ExternalLinkage
  61 };
  62
  63 /// Describes the different kinds of language linkage
  64 /// (C++ [dcl.link]) that an entity may have.
  65 enum LanguageLinkage {
  66   CLanguageLinkage,
  67   CXXLanguageLinkage,
  68   NoLanguageLinkage
  69 };
  70
  71 /// A more specific kind of linkage than enum Linkage.
  72 ///
  73 /// This is relevant to CodeGen and AST file reading.
  74 enum GVALinkage {
  75   GVA_Internal,
  76   GVA_AvailableExternally,
  77   GVA_DiscardableODR,
  78   GVA_StrongExternal,
  79   GVA_StrongODR
  80 };
  81
  82 inline bool isDiscardableGVALinkage(GVALinkage L) {
  83   return L <= GVA_DiscardableODR;
  84 }
  85
  86 inline bool isExternallyVisible(Linkage L) {
  87   return L >= VisibleNoLinkage;
  88 }
  89
  90 inline Linkage getFormalLinkage(Linkage L) {
  91   switch (L) {
  92   case UniqueExternalLinkage:
  93     return ExternalLinkage;
  94   case VisibleNoLinkage:
  95     return NoLinkage;
  96   case ModuleInternalLinkage:
  97     return InternalLinkage;
  98   default:
  99     return L;
 100   }
 101 }
 102
 103 inline bool isExternalFormalLinkage(Linkage L) {
 104   return getFormalLinkage(L) == ExternalLinkage;
 105 }
 106
 107 /// Compute the minimum linkage given two linkages.
 108 ///
 109 /// The linkage can be interpreted as a pair formed by the formal linkage and
 110 /// a boolean for external visibility. This is just what getFormalLinkage and
 111 /// isExternallyVisible return. We want the minimum of both components. The
 112 /// Linkage enum is defined in an order that makes this simple, we just need
 113 /// special cases for when VisibleNoLinkage would lose the visible bit and
 114 /// become NoLinkage.
 115 inline Linkage minLinkage(Linkage L1, Linkage L2) {
 116   if (L2 == VisibleNoLinkage)
 117     std::swap(L1, L2);
 118   if (L1 == VisibleNoLinkage) {
 119     if (L2 == InternalLinkage)
 120       return NoLinkage;
 121     if (L2 == UniqueExternalLinkage)
 122       return NoLinkage;
 123   }
 124   return L1 < L2 ? L1 : L2;
 125 }
 126
 127 } // namespace clang
 128
 129 #endif // LLVM_CLANG_BASIC_LINKAGE_H