Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.