clang  8.0.0svn
Linkage.h
Go to the documentation of this file.
1 //===----- Linkage.h - Linkage calculation-related 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 // This file provides AST-internal utilities for linkage and visibility
11 // calculation.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_LIB_AST_LINKAGE_H
16 #define LLVM_CLANG_LIB_AST_LINKAGE_H
17 
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.
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.
36  /// Whether all visibility should be ignored. When set, we're only interested
37  /// in computing linkage.
38  unsigned IgnoreAllVisibility : 1;
39 
41 
45 
48  }
49 
50  bool isTypeVisibility() const {
52  }
53  bool isValueVisibility() const {
55  }
56 
57  /// Do an LV computation when we only care about the linkage.
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 
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 *,
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,
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);
152  return computeTypeLinkageInfo(T.getTypePtr());
153  }
154 
155  LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D);
156 
157  LinkageInfo getTypeLinkageAndVisibility(const Type *T);
159  return getTypeLinkageAndVisibility(T.getTypePtr());
160  }
161 };
162 } // namespace clang
163 
164 #endif
Represents a function declaration or definition.
Definition: Decl.h:1732
LVComputationKind(NamedDecl::ExplicitVisibilityKind EK)
Definition: Linkage.h:42
A (possibly-)qualified type.
Definition: Type.h:642
C Language Family Type Representation.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
The base class of the type hierarchy.
Definition: Type.h:1415
ExplicitVisibilityKind
Kinds of explicit visibility.
Definition: Decl.h:398
Represents a variable template specialization, which refers to a variable template with a given set o...
LinkageInfo getTypeLinkageAndVisibility(QualType T)
Definition: Linkage.h:158
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
unsigned ExplicitKind
The kind of entity whose visibility is ultimately being computed; visibility computations for types a...
Definition: Linkage.h:32
Represents a class template specialization, which refers to a class template with a given set of temp...
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:508
Kinds of LV computation.
Definition: Linkage.h:29
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6046
LinkageInfo computeTypeLinkageInfo(QualType T)
Definition: Linkage.h:151
unsigned IgnoreExplicitVisibility
Whether explicit visibility attributes should be ignored.
Definition: Linkage.h:35
bool isTypeVisibility() const
Definition: Linkage.h:50
unsigned IgnoreAllVisibility
Whether all visibility should be ignored.
Definition: Linkage.h:38
bool isValueVisibility() const
Definition: Linkage.h:53
The result type of a method or function.
#define false
Definition: stdbool.h:33
Kind
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1261
Do an LV computation for, ultimately, a non-type declaration.
Definition: Decl.h:407
Do an LV computation for, ultimately, a type.
Definition: Decl.h:402
NamedDecl::ExplicitVisibilityKind getExplicitVisibilityKind() const
Definition: Linkage.h:46
A template argument list.
Definition: DeclTemplate.h:210
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
This represents a decl that may have a name.
Definition: Decl.h:248
static LVComputationKind forLinkageOnly()
Do an LV computation when we only care about the linkage.
Definition: Linkage.h:58