1 //===--- DeclOpenMP.cpp - Declaration OpenMP AST Node Implementation ------===//
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
7 //===----------------------------------------------------------------------===//
9 /// This file implements OMPThreadPrivateDecl, OMPCapturedExprDecl
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/DeclBase.h"
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/AST/Expr.h"
20 using namespace clang;
22 //===----------------------------------------------------------------------===//
23 // OMPThreadPrivateDecl Implementation.
24 //===----------------------------------------------------------------------===//
26 void OMPThreadPrivateDecl::anchor() { }
28 OMPThreadPrivateDecl *OMPThreadPrivateDecl::Create(ASTContext &C,
31 ArrayRef<Expr *> VL) {
32 OMPThreadPrivateDecl *D =
33 new (C, DC, additionalSizeToAlloc<Expr *>(VL.size()))
34 OMPThreadPrivateDecl(OMPThreadPrivate, DC, L);
35 D->NumVars = VL.size();
40 OMPThreadPrivateDecl *OMPThreadPrivateDecl::CreateDeserialized(ASTContext &C,
43 OMPThreadPrivateDecl *D = new (C, ID, additionalSizeToAlloc<Expr *>(N))
44 OMPThreadPrivateDecl(OMPThreadPrivate, nullptr, SourceLocation());
49 void OMPThreadPrivateDecl::setVars(ArrayRef<Expr *> VL) {
50 assert(VL.size() == NumVars &&
51 "Number of variables is not the same as the preallocated buffer");
52 std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
55 //===----------------------------------------------------------------------===//
56 // OMPAllocateDecl Implementation.
57 //===----------------------------------------------------------------------===//
59 void OMPAllocateDecl::anchor() { }
61 OMPAllocateDecl *OMPAllocateDecl::Create(ASTContext &C, DeclContext *DC,
62 SourceLocation L, ArrayRef<Expr *> VL,
63 ArrayRef<OMPClause *> CL) {
64 OMPAllocateDecl *D = new (
65 C, DC, additionalSizeToAlloc<Expr *, OMPClause *>(VL.size(), CL.size()))
66 OMPAllocateDecl(OMPAllocate, DC, L);
67 D->NumVars = VL.size();
69 D->NumClauses = CL.size();
74 OMPAllocateDecl *OMPAllocateDecl::CreateDeserialized(ASTContext &C, unsigned ID,
78 new (C, ID, additionalSizeToAlloc<Expr *, OMPClause *>(NVars, NClauses))
79 OMPAllocateDecl(OMPAllocate, nullptr, SourceLocation());
81 D->NumClauses = NClauses;
85 void OMPAllocateDecl::setVars(ArrayRef<Expr *> VL) {
86 assert(VL.size() == NumVars &&
87 "Number of variables is not the same as the preallocated buffer");
88 std::uninitialized_copy(VL.begin(), VL.end(), getTrailingObjects<Expr *>());
91 void OMPAllocateDecl::setClauses(ArrayRef<OMPClause *> CL) {
92 assert(CL.size() == NumClauses &&
93 "Number of variables is not the same as the preallocated buffer");
94 std::uninitialized_copy(CL.begin(), CL.end(),
95 getTrailingObjects<OMPClause *>());
98 //===----------------------------------------------------------------------===//
99 // OMPRequiresDecl Implementation.
100 //===----------------------------------------------------------------------===//
102 void OMPRequiresDecl::anchor() {}
104 OMPRequiresDecl *OMPRequiresDecl::Create(ASTContext &C, DeclContext *DC,
106 ArrayRef<OMPClause *> CL) {
108 new (C, DC, additionalSizeToAlloc<OMPClause *>(CL.size()))
109 OMPRequiresDecl(OMPRequires, DC, L);
110 D->NumClauses = CL.size();
115 OMPRequiresDecl *OMPRequiresDecl::CreateDeserialized(ASTContext &C, unsigned ID,
117 OMPRequiresDecl *D = new (C, ID, additionalSizeToAlloc<OMPClause *>(N))
118 OMPRequiresDecl(OMPRequires, nullptr, SourceLocation());
123 void OMPRequiresDecl::setClauses(ArrayRef<OMPClause *> CL) {
124 assert(CL.size() == NumClauses &&
125 "Number of clauses is not the same as the preallocated buffer");
126 std::uninitialized_copy(CL.begin(), CL.end(),
127 getTrailingObjects<OMPClause *>());
130 //===----------------------------------------------------------------------===//
131 // OMPDeclareReductionDecl Implementation.
132 //===----------------------------------------------------------------------===//
134 OMPDeclareReductionDecl::OMPDeclareReductionDecl(
135 Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
136 QualType Ty, OMPDeclareReductionDecl *PrevDeclInScope)
137 : ValueDecl(DK, DC, L, Name, Ty), DeclContext(DK), Combiner(nullptr),
138 PrevDeclInScope(PrevDeclInScope) {
139 setInitializer(nullptr, CallInit);
142 void OMPDeclareReductionDecl::anchor() {}
144 OMPDeclareReductionDecl *OMPDeclareReductionDecl::Create(
145 ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name,
146 QualType T, OMPDeclareReductionDecl *PrevDeclInScope) {
147 return new (C, DC) OMPDeclareReductionDecl(OMPDeclareReduction, DC, L, Name,
151 OMPDeclareReductionDecl *
152 OMPDeclareReductionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
153 return new (C, ID) OMPDeclareReductionDecl(
154 OMPDeclareReduction, /*DC=*/nullptr, SourceLocation(), DeclarationName(),
155 QualType(), /*PrevDeclInScope=*/nullptr);
158 OMPDeclareReductionDecl *OMPDeclareReductionDecl::getPrevDeclInScope() {
159 return cast_or_null<OMPDeclareReductionDecl>(
160 PrevDeclInScope.get(getASTContext().getExternalSource()));
162 const OMPDeclareReductionDecl *
163 OMPDeclareReductionDecl::getPrevDeclInScope() const {
164 return cast_or_null<OMPDeclareReductionDecl>(
165 PrevDeclInScope.get(getASTContext().getExternalSource()));
168 //===----------------------------------------------------------------------===//
169 // OMPDeclareMapperDecl Implementation.
170 //===----------------------------------------------------------------------===//
172 void OMPDeclareMapperDecl::anchor() {}
174 OMPDeclareMapperDecl *
175 OMPDeclareMapperDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
176 DeclarationName Name, QualType T,
177 DeclarationName VarName,
178 OMPDeclareMapperDecl *PrevDeclInScope) {
179 return new (C, DC) OMPDeclareMapperDecl(OMPDeclareMapper, DC, L, Name, T,
180 VarName, PrevDeclInScope);
183 OMPDeclareMapperDecl *OMPDeclareMapperDecl::CreateDeserialized(ASTContext &C,
186 auto *D = new (C, ID)
187 OMPDeclareMapperDecl(OMPDeclareMapper, /*DC=*/nullptr, SourceLocation(),
188 DeclarationName(), QualType(), DeclarationName(),
189 /*PrevDeclInScope=*/nullptr);
191 auto **ClauseStorage = C.Allocate<OMPClause *>(N);
192 D->Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, N);
197 /// Creates an array of clauses to this mapper declaration and intializes
198 /// them. The space used to store clause pointers is dynamically allocated,
199 /// because we do not know the number of clauses when creating
200 /// OMPDeclareMapperDecl
201 void OMPDeclareMapperDecl::CreateClauses(ASTContext &C,
202 ArrayRef<OMPClause *> CL) {
203 assert(Clauses.empty() && "Number of clauses should be 0 on initialization");
204 size_t NumClauses = CL.size();
206 auto **ClauseStorage = C.Allocate<OMPClause *>(NumClauses);
207 Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, NumClauses);
212 void OMPDeclareMapperDecl::setClauses(ArrayRef<OMPClause *> CL) {
213 assert(CL.size() == Clauses.size() &&
214 "Number of clauses is not the same as the preallocated buffer");
215 std::uninitialized_copy(CL.begin(), CL.end(), Clauses.data());
218 OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() {
219 return cast_or_null<OMPDeclareMapperDecl>(
220 PrevDeclInScope.get(getASTContext().getExternalSource()));
223 const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const {
224 return cast_or_null<OMPDeclareMapperDecl>(
225 PrevDeclInScope.get(getASTContext().getExternalSource()));
228 //===----------------------------------------------------------------------===//
229 // OMPCapturedExprDecl Implementation.
230 //===----------------------------------------------------------------------===//
232 void OMPCapturedExprDecl::anchor() {}
234 OMPCapturedExprDecl *OMPCapturedExprDecl::Create(ASTContext &C, DeclContext *DC,
235 IdentifierInfo *Id, QualType T,
236 SourceLocation StartLoc) {
237 return new (C, DC) OMPCapturedExprDecl(
238 C, DC, Id, T, C.getTrivialTypeSourceInfo(T), StartLoc);
241 OMPCapturedExprDecl *OMPCapturedExprDecl::CreateDeserialized(ASTContext &C,
243 return new (C, ID) OMPCapturedExprDecl(C, nullptr, nullptr, QualType(),
244 /*TInfo=*/nullptr, SourceLocation());
247 SourceRange OMPCapturedExprDecl::getSourceRange() const {
249 return SourceRange(getInit()->getBeginLoc(), getInit()->getEndLoc());