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

   1 //===--- Visibility.h - Visibility 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 clang::Visibility enumeration and various utility
  11 /// functions.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14 #ifndef LLVM_CLANG_BASIC_VISIBILITY_H
  15 #define LLVM_CLANG_BASIC_VISIBILITY_H
  16
  17 #include "clang/Basic/Linkage.h"
  18 #include <cassert>
  19 #include <cstdint>
  20
  21 namespace clang {
  22
  23 /// Describes the different kinds of visibility that a declaration
  24 /// may have.
  25 ///
  26 /// Visibility determines how a declaration interacts with the dynamic
  27 /// linker.  It may also affect whether the symbol can be found by runtime
  28 /// symbol lookup APIs.
  29 ///
  30 /// Visibility is not described in any language standard and
  31 /// (nonetheless) sometimes has odd behavior.  Not all platforms
  32 /// support all visibility kinds.
  33 enum Visibility {
  34   /// Objects with "hidden" visibility are not seen by the dynamic
  35   /// linker.
  36   HiddenVisibility,
  37
  38   /// Objects with "protected" visibility are seen by the dynamic
  39   /// linker but always dynamically resolve to an object within this
  40   /// shared object.
  41   ProtectedVisibility,
  42
  43   /// Objects with "default" visibility are seen by the dynamic linker
  44   /// and act like normal objects.
  45   DefaultVisibility
  46 };
  47
  48 inline Visibility minVisibility(Visibility L, Visibility R) {
  49   return L < R ? L : R;
  50 }
  51
  52 class LinkageInfo {
  53   uint8_t linkage_    : 3;
  54   uint8_t visibility_ : 2;
  55   uint8_t explicit_   : 1;
  56
  57   void setVisibility(Visibility V, bool E) { visibility_ = V; explicit_ = E; }
  58 public:
  59   LinkageInfo() : linkage_(ExternalLinkage), visibility_(DefaultVisibility),
  60                   explicit_(false) {}
  61   LinkageInfo(Linkage L, Visibility V, bool E)
  62     : linkage_(L), visibility_(V), explicit_(E) {
  63     assert(getLinkage() == L && getVisibility() == V &&
  64            isVisibilityExplicit() == E && "Enum truncated!");
  65   }
  66
  67   static LinkageInfo external() {
  68     return LinkageInfo();
  69   }
  70   static LinkageInfo internal() {
  71     return LinkageInfo(InternalLinkage, DefaultVisibility, false);
  72   }
  73   static LinkageInfo uniqueExternal() {
  74     return LinkageInfo(UniqueExternalLinkage, DefaultVisibility, false);
  75   }
  76   static LinkageInfo none() {
  77     return LinkageInfo(NoLinkage, DefaultVisibility, false);
  78   }
  79   static LinkageInfo visible_none() {
  80     return LinkageInfo(VisibleNoLinkage, DefaultVisibility, false);
  81   }
  82
  83   Linkage getLinkage() const { return (Linkage)linkage_; }
  84   Visibility getVisibility() const { return (Visibility)visibility_; }
  85   bool isVisibilityExplicit() const { return explicit_; }
  86
  87   void setLinkage(Linkage L) { linkage_ = L; }
  88
  89   void mergeLinkage(Linkage L) {
  90     setLinkage(minLinkage(getLinkage(), L));
  91   }
  92   void mergeLinkage(LinkageInfo other) {
  93     mergeLinkage(other.getLinkage());
  94   }
  95
  96   void mergeExternalVisibility(Linkage L) {
  97     Linkage ThisL = getLinkage();
  98     if (!isExternallyVisible(L)) {
  99       if (ThisL == VisibleNoLinkage)
 100         ThisL = NoLinkage;
 101       else if (ThisL == ExternalLinkage)
 102         ThisL = UniqueExternalLinkage;
 103     }
 104     setLinkage(ThisL);
 105   }
 106   void mergeExternalVisibility(LinkageInfo Other) {
 107     mergeExternalVisibility(Other.getLinkage());
 108   }
 109
 110   /// Merge in the visibility 'newVis'.
 111   void mergeVisibility(Visibility newVis, bool newExplicit) {
 112     Visibility oldVis = getVisibility();
 113
 114     // Never increase visibility.
 115     if (oldVis < newVis)
 116       return;
 117
 118     // If the new visibility is the same as the old and the new
 119     // visibility isn't explicit, we have nothing to add.
 120     if (oldVis == newVis && !newExplicit)
 121       return;
 122
 123     // Otherwise, we're either decreasing visibility or making our
 124     // existing visibility explicit.
 125     setVisibility(newVis, newExplicit);
 126   }
 127   void mergeVisibility(LinkageInfo other) {
 128     mergeVisibility(other.getVisibility(), other.isVisibilityExplicit());
 129   }
 130
 131   /// Merge both linkage and visibility.
 132   void merge(LinkageInfo other) {
 133     mergeLinkage(other);
 134     mergeVisibility(other);
 135   }
 136
 137   /// Merge linkage and conditionally merge visibility.
 138   void mergeMaybeWithVisibility(LinkageInfo other, bool withVis) {
 139     mergeLinkage(other);
 140     if (withVis) mergeVisibility(other);
 141   }
 142 };
 143 }
 144
 145 #endif // LLVM_CLANG_BASIC_VISIBILITY_H