clang 19.0.0git
GlobalDecl.h
Go to the documentation of this file.
1//===- GlobalDecl.h - Global declaration holder -----------------*- 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// A GlobalDecl can hold either a regular variable/function or a C++ ctor/dtor
10// together with its type.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_AST_GLOBALDECL_H
15#define LLVM_CLANG_AST_GLOBALDECL_H
16
17#include "clang/AST/Attr.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclObjC.h"
22#include "clang/Basic/ABI.h"
23#include "clang/Basic/LLVM.h"
24#include "llvm/ADT/DenseMapInfo.h"
25#include "llvm/ADT/PointerIntPair.h"
26#include "llvm/Support/Casting.h"
27#include "llvm/Support/type_traits.h"
28#include <cassert>
29
30namespace clang {
31
32enum class DynamicInitKind : unsigned {
33 NoStub = 0,
35 AtExit,
37};
38
39enum class KernelReferenceKind : unsigned {
40 Kernel = 0,
41 Stub = 1,
42};
43
44/// GlobalDecl - represents a global declaration. This can either be a
45/// CXXConstructorDecl and the constructor type (Base, Complete).
46/// a CXXDestructorDecl and the destructor type (Base, Complete),
47/// a FunctionDecl and the kernel reference type (Kernel, Stub), or
48/// a VarDecl, a FunctionDecl or a BlockDecl.
49///
50/// When a new type of GlobalDecl is added, the following places should
51/// be updated to convert a Decl* to a GlobalDecl:
52/// PredefinedExpr::ComputeName() in lib/AST/Expr.cpp.
53/// getParentOfLocalEntity() in lib/AST/ItaniumMangle.cpp
54/// ASTNameGenerator::Implementation::writeFuncOrVarName in lib/AST/Mangle.cpp
55///
57 llvm::PointerIntPair<const Decl *, 3> Value;
58 unsigned MultiVersionIndex = 0;
59
60 void Init(const Decl *D) {
61 assert(!isa<CXXConstructorDecl>(D) && "Use other ctor with ctor decls!");
62 assert(!isa<CXXDestructorDecl>(D) && "Use other ctor with dtor decls!");
63 assert(!D->hasAttr<CUDAGlobalAttr>() && "Use other ctor with GPU kernels!");
64
65 Value.setPointer(D);
66 }
67
68public:
69 GlobalDecl() = default;
70 GlobalDecl(const VarDecl *D) { Init(D);}
71 GlobalDecl(const FunctionDecl *D, unsigned MVIndex = 0)
72 : MultiVersionIndex(MVIndex) {
73 if (!D->hasAttr<CUDAGlobalAttr>()) {
74 Init(D);
75 return;
76 }
77 Value.setPointerAndInt(D, unsigned(getDefaultKernelReference(D)));
78 }
80 : Value(D, unsigned(Kind)) {
81 assert(D->hasAttr<CUDAGlobalAttr>() && "Decl is not a GPU kernel!");
82 }
83 GlobalDecl(const NamedDecl *D) { Init(D); }
84 GlobalDecl(const BlockDecl *D) { Init(D); }
92 : Value(D, unsigned(StubKind)) {}
93
95 GlobalDecl CanonGD;
96 CanonGD.Value.setPointer(Value.getPointer()->getCanonicalDecl());
97 CanonGD.Value.setInt(Value.getInt());
98 CanonGD.MultiVersionIndex = MultiVersionIndex;
99
100 return CanonGD;
101 }
102
103 const Decl *getDecl() const { return Value.getPointer(); }
104
106 assert(isa<CXXConstructorDecl>(getDecl()) && "Decl is not a ctor!");
107 return static_cast<CXXCtorType>(Value.getInt());
108 }
109
111 assert(isa<CXXDestructorDecl>(getDecl()) && "Decl is not a dtor!");
112 return static_cast<CXXDtorType>(Value.getInt());
113 }
114
116 assert(isa<VarDecl>(getDecl()) &&
117 cast<VarDecl>(getDecl())->hasGlobalStorage() &&
118 "Decl is not a global variable!");
119 return static_cast<DynamicInitKind>(Value.getInt());
120 }
121
122 unsigned getMultiVersionIndex() const {
123 assert(isa<FunctionDecl>(
124 getDecl()) &&
125 !cast<FunctionDecl>(getDecl())->hasAttr<CUDAGlobalAttr>() &&
126 !isa<CXXConstructorDecl>(getDecl()) &&
127 !isa<CXXDestructorDecl>(getDecl()) &&
128 "Decl is not a plain FunctionDecl!");
129 return MultiVersionIndex;
130 }
131
133 assert(((isa<FunctionDecl>(getDecl()) &&
134 cast<FunctionDecl>(getDecl())->hasAttr<CUDAGlobalAttr>()) ||
135 (isa<FunctionTemplateDecl>(getDecl()) &&
136 cast<FunctionTemplateDecl>(getDecl())
137 ->getTemplatedDecl()
138 ->hasAttr<CUDAGlobalAttr>())) &&
139 "Decl is not a GPU kernel!");
140 return static_cast<KernelReferenceKind>(Value.getInt());
141 }
142
143 friend bool operator==(const GlobalDecl &LHS, const GlobalDecl &RHS) {
144 return LHS.Value == RHS.Value &&
145 LHS.MultiVersionIndex == RHS.MultiVersionIndex;
146 }
147
148 bool operator!=(const GlobalDecl &Other) const {
149 return !(*this == Other);
150 }
151
152 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
153
154 explicit operator bool() const { return getAsOpaquePtr(); }
155
157 GlobalDecl GD;
158 GD.Value.setFromOpaqueValue(P);
159 return GD;
160 }
161
163 return D->getLangOpts().CUDAIsDevice ? KernelReferenceKind::Kernel
165 }
166
168 GlobalDecl Result(*this);
169 Result.Value.setPointer(D);
170 return Result;
171 }
172
174 assert(isa<CXXConstructorDecl>(getDecl()));
175 GlobalDecl Result(*this);
176 Result.Value.setInt(Type);
177 return Result;
178 }
179
181 assert(isa<CXXDestructorDecl>(getDecl()));
182 GlobalDecl Result(*this);
183 Result.Value.setInt(Type);
184 return Result;
185 }
186
188 assert(isa<FunctionDecl>(getDecl()) &&
189 !cast<FunctionDecl>(getDecl())->hasAttr<CUDAGlobalAttr>() &&
190 !isa<CXXConstructorDecl>(getDecl()) &&
191 !isa<CXXDestructorDecl>(getDecl()) &&
192 "Decl is not a plain FunctionDecl!");
193 GlobalDecl Result(*this);
194 Result.MultiVersionIndex = Index;
195 return Result;
196 }
197
199 assert(isa<FunctionDecl>(getDecl()) &&
200 cast<FunctionDecl>(getDecl())->hasAttr<CUDAGlobalAttr>() &&
201 "Decl is not a GPU kernel!");
202 GlobalDecl Result(*this);
203 Result.Value.setInt(unsigned(Kind));
204 return Result;
205 }
206};
207
208} // namespace clang
209
210namespace llvm {
211
212 template<> struct DenseMapInfo<clang::GlobalDecl> {
214 return clang::GlobalDecl();
215 }
216
219 getFromOpaquePtr(reinterpret_cast<void*>(-1));
220 }
221
222 static unsigned getHashValue(clang::GlobalDecl GD) {
223 return DenseMapInfo<void*>::getHashValue(GD.getAsOpaquePtr());
224 }
225
226 static bool isEqual(clang::GlobalDecl LHS,
227 clang::GlobalDecl RHS) {
228 return LHS == RHS;
229 }
230 };
231
232} // namespace llvm
233
234#endif // LLVM_CLANG_AST_GLOBALDECL_H
Enums/classes describing ABI related information about constructors, destructors and thunks.
StringRef P
const Decl * D
enum clang::sema::@1650::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines OpenMP nodes for declarative directives.
Defines the C++ template declaration subclasses.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4467
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2535
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2799
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4666
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Represents a function declaration or definition.
Definition: Decl.h:1932
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
GlobalDecl(const OMPDeclareReductionDecl *D)
Definition: GlobalDecl.h:87
GlobalDecl(const CapturedDecl *D)
Definition: GlobalDecl.h:85
GlobalDecl getWithMultiVersionIndex(unsigned Index)
Definition: GlobalDecl.h:187
GlobalDecl getWithCtorType(CXXCtorType Type)
Definition: GlobalDecl.h:173
GlobalDecl(const FunctionDecl *D, KernelReferenceKind Kind)
Definition: GlobalDecl.h:79
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:105
GlobalDecl(const FunctionDecl *D, unsigned MVIndex=0)
Definition: GlobalDecl.h:71
GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)
Definition: GlobalDecl.h:198
GlobalDecl getCanonicalDecl() const
Definition: GlobalDecl.h:94
friend bool operator==(const GlobalDecl &LHS, const GlobalDecl &RHS)
Definition: GlobalDecl.h:143
GlobalDecl(const VarDecl *D)
Definition: GlobalDecl.h:70
KernelReferenceKind getKernelReferenceKind() const
Definition: GlobalDecl.h:132
static GlobalDecl getFromOpaquePtr(void *P)
Definition: GlobalDecl.h:156
GlobalDecl getWithDecl(const Decl *D)
Definition: GlobalDecl.h:167
unsigned getMultiVersionIndex() const
Definition: GlobalDecl.h:122
void * getAsOpaquePtr() const
Definition: GlobalDecl.h:152
GlobalDecl(const CXXConstructorDecl *D, CXXCtorType Type)
Definition: GlobalDecl.h:89
DynamicInitKind getDynamicInitKind() const
Definition: GlobalDecl.h:115
GlobalDecl getWithDtorType(CXXDtorType Type)
Definition: GlobalDecl.h:180
GlobalDecl(const OMPDeclareMapperDecl *D)
Definition: GlobalDecl.h:88
bool operator!=(const GlobalDecl &Other) const
Definition: GlobalDecl.h:148
GlobalDecl(const VarDecl *D, DynamicInitKind StubKind)
Definition: GlobalDecl.h:91
static KernelReferenceKind getDefaultKernelReference(const FunctionDecl *D)
Definition: GlobalDecl.h:162
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:110
const Decl * getDecl() const
Definition: GlobalDecl.h:103
GlobalDecl(const BlockDecl *D)
Definition: GlobalDecl.h:84
GlobalDecl()=default
GlobalDecl(const CXXDestructorDecl *D, CXXDtorType Type)
Definition: GlobalDecl.h:90
GlobalDecl(const ObjCMethodDecl *D)
Definition: GlobalDecl.h:86
GlobalDecl(const NamedDecl *D)
Definition: GlobalDecl.h:83
This represents a decl that may have a name.
Definition: Decl.h:249
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:287
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:177
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
The base class of the type hierarchy.
Definition: Type.h:1829
Represents a variable declaration or definition.
Definition: Decl.h:879
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
@ Result
The result type of a method or function.
DynamicInitKind
Definition: GlobalDecl.h:32
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
KernelReferenceKind
Definition: GlobalDecl.h:39
@ Other
Other implicit parameter.
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
#define bool
Definition: stdbool.h:24
static bool isEqual(clang::GlobalDecl LHS, clang::GlobalDecl RHS)
Definition: GlobalDecl.h:226
static clang::GlobalDecl getTombstoneKey()
Definition: GlobalDecl.h:217
static unsigned getHashValue(clang::GlobalDecl GD)
Definition: GlobalDecl.h:222
static clang::GlobalDecl getEmptyKey()
Definition: GlobalDecl.h:213