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