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