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