1 //===----- Linkage.h - Linkage calculation-related 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 // This file provides AST-internal utilities for linkage and visibility 10 // calculation. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_LIB_AST_LINKAGE_H 15 #define LLVM_CLANG_LIB_AST_LINKAGE_H 16 17 #include "clang/AST/ASTFwd.h" 18 #include "clang/AST/Decl.h" 19 #include "clang/AST/DeclCXX.h" 20 #include "clang/AST/Type.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/ADT/Optional.h" 23 #include "llvm/ADT/PointerIntPair.h" 24 25 namespace clang { 26 /// Kinds of LV computation. The linkage side of the computation is 27 /// always the same, but different things can change how visibility is 28 /// computed. 29 struct LVComputationKind { 30 /// The kind of entity whose visibility is ultimately being computed; 31 /// visibility computations for types and non-types follow different rules. 32 unsigned ExplicitKind : 1; 33 /// Whether explicit visibility attributes should be ignored. When set, 34 /// visibility may only be restricted by the visibility of template arguments. 35 unsigned IgnoreExplicitVisibility : 1; 36 /// Whether all visibility should be ignored. When set, we're only interested 37 /// in computing linkage. 38 unsigned IgnoreAllVisibility : 1; 39 40 enum { NumLVComputationKindBits = 3 }; 41 42 explicit LVComputationKind(NamedDecl::ExplicitVisibilityKind EK) 43 : ExplicitKind(EK), IgnoreExplicitVisibility(false), 44 IgnoreAllVisibility(false) {} 45 46 NamedDecl::ExplicitVisibilityKind getExplicitVisibilityKind() const { 47 return static_cast<NamedDecl::ExplicitVisibilityKind>(ExplicitKind); 48 } 49 50 bool isTypeVisibility() const { 51 return getExplicitVisibilityKind() == NamedDecl::VisibilityForType; 52 } 53 bool isValueVisibility() const { 54 return getExplicitVisibilityKind() == NamedDecl::VisibilityForValue; 55 } 56 57 /// Do an LV computation when we only care about the linkage. 58 static LVComputationKind forLinkageOnly() { 59 LVComputationKind Result(NamedDecl::VisibilityForValue); 60 Result.IgnoreExplicitVisibility = true; 61 Result.IgnoreAllVisibility = true; 62 return Result; 63 } 64 65 unsigned toBits() { 66 unsigned Bits = 0; 67 Bits = (Bits << 1) | ExplicitKind; 68 Bits = (Bits << 1) | IgnoreExplicitVisibility; 69 Bits = (Bits << 1) | IgnoreAllVisibility; 70 return Bits; 71 } 72 }; 73 74 class LinkageComputer { 75 // We have a cache for repeated linkage/visibility computations. This saves us 76 // from exponential behavior in heavily templated code, such as: 77 // 78 // template <typename T, typename V> struct {}; 79 // using A = int; 80 // using B = Foo<A, A>; 81 // using C = Foo<B, B>; 82 // using D = Foo<C, C>; 83 // 84 // The integer represents an LVComputationKind. 85 using QueryType = 86 llvm::PointerIntPair<const NamedDecl *, 87 LVComputationKind::NumLVComputationKindBits>; 88 llvm::SmallDenseMap<QueryType, LinkageInfo, 8> CachedLinkageInfo; 89 90 static QueryType makeCacheKey(const NamedDecl *ND, LVComputationKind Kind) { 91 return QueryType(ND, Kind.toBits()); 92 } 93 94 llvm::Optional<LinkageInfo> lookup(const NamedDecl *ND, 95 LVComputationKind Kind) const { 96 auto Iter = CachedLinkageInfo.find(makeCacheKey(ND, Kind)); 97 if (Iter == CachedLinkageInfo.end()) 98 return None; 99 return Iter->second; 100 } 101 102 void cache(const NamedDecl *ND, LVComputationKind Kind, LinkageInfo Info) { 103 CachedLinkageInfo[makeCacheKey(ND, Kind)] = Info; 104 } 105 106 LinkageInfo getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args, 107 LVComputationKind computation); 108 109 LinkageInfo getLVForTemplateArgumentList(const TemplateArgumentList &TArgs, 110 LVComputationKind computation); 111 112 void mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn, 113 const FunctionTemplateSpecializationInfo *specInfo, 114 LVComputationKind computation); 115 116 void mergeTemplateLV(LinkageInfo &LV, 117 const ClassTemplateSpecializationDecl *spec, 118 LVComputationKind computation); 119 120 void mergeTemplateLV(LinkageInfo &LV, 121 const VarTemplateSpecializationDecl *spec, 122 LVComputationKind computation); 123 124 LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, 125 LVComputationKind computation, 126 bool IgnoreVarTypeLinkage); 127 128 LinkageInfo getLVForClassMember(const NamedDecl *D, 129 LVComputationKind computation, 130 bool IgnoreVarTypeLinkage); 131 132 LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl, 133 LVComputationKind computation); 134 135 LinkageInfo getLVForLocalDecl(const NamedDecl *D, 136 LVComputationKind computation); 137 138 LinkageInfo getLVForType(const Type &T, LVComputationKind computation); 139 140 LinkageInfo getLVForTemplateParameterList(const TemplateParameterList *Params, 141 LVComputationKind computation); 142 143 public: 144 LinkageInfo computeLVForDecl(const NamedDecl *D, 145 LVComputationKind computation, 146 bool IgnoreVarTypeLinkage = false); 147 148 LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation); 149 150 LinkageInfo computeTypeLinkageInfo(const Type *T); 151 LinkageInfo computeTypeLinkageInfo(QualType T) { 152 return computeTypeLinkageInfo(T.getTypePtr()); 153 } 154 155 LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D); 156 157 LinkageInfo getTypeLinkageAndVisibility(const Type *T); 158 LinkageInfo getTypeLinkageAndVisibility(QualType T) { 159 return getTypeLinkageAndVisibility(T.getTypePtr()); 160 } 161 }; 162 } // namespace clang 163 164 #endif 165