Home | History | Annotate | Line # | Download | only in Basic 
      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