|
150
|
1 //===--- DeclOpenMP.cpp - Declaration OpenMP AST Node Implementation ------===//
|
|
|
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 /// \file
|
|
|
9 /// This file implements OMPThreadPrivateDecl, OMPCapturedExprDecl
|
|
|
10 /// classes.
|
|
|
11 ///
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13
|
|
|
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"
|
|
|
19
|
|
|
20 using namespace clang;
|
|
|
21
|
|
|
22 //===----------------------------------------------------------------------===//
|
|
|
23 // OMPThreadPrivateDecl Implementation.
|
|
|
24 //===----------------------------------------------------------------------===//
|
|
|
25
|
|
|
26 void OMPThreadPrivateDecl::anchor() { }
|
|
|
27
|
|
|
28 OMPThreadPrivateDecl *OMPThreadPrivateDecl::Create(ASTContext &C,
|
|
|
29 DeclContext *DC,
|
|
|
30 SourceLocation L,
|
|
|
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();
|
|
|
36 D->setVars(VL);
|
|
|
37 return D;
|
|
|
38 }
|
|
|
39
|
|
|
40 OMPThreadPrivateDecl *OMPThreadPrivateDecl::CreateDeserialized(ASTContext &C,
|
|
|
41 unsigned ID,
|
|
|
42 unsigned N) {
|
|
|
43 OMPThreadPrivateDecl *D = new (C, ID, additionalSizeToAlloc<Expr *>(N))
|
|
|
44 OMPThreadPrivateDecl(OMPThreadPrivate, nullptr, SourceLocation());
|
|
|
45 D->NumVars = N;
|
|
|
46 return D;
|
|
|
47 }
|
|
|
48
|
|
|
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 *>());
|
|
|
53 }
|
|
|
54
|
|
|
55 //===----------------------------------------------------------------------===//
|
|
|
56 // OMPAllocateDecl Implementation.
|
|
|
57 //===----------------------------------------------------------------------===//
|
|
|
58
|
|
|
59 void OMPAllocateDecl::anchor() { }
|
|
|
60
|
|
|
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();
|
|
|
68 D->setVars(VL);
|
|
|
69 D->NumClauses = CL.size();
|
|
|
70 D->setClauses(CL);
|
|
|
71 return D;
|
|
|
72 }
|
|
|
73
|
|
|
74 OMPAllocateDecl *OMPAllocateDecl::CreateDeserialized(ASTContext &C, unsigned ID,
|
|
|
75 unsigned NVars,
|
|
|
76 unsigned NClauses) {
|
|
|
77 OMPAllocateDecl *D =
|
|
|
78 new (C, ID, additionalSizeToAlloc<Expr *, OMPClause *>(NVars, NClauses))
|
|
|
79 OMPAllocateDecl(OMPAllocate, nullptr, SourceLocation());
|
|
|
80 D->NumVars = NVars;
|
|
|
81 D->NumClauses = NClauses;
|
|
|
82 return D;
|
|
|
83 }
|
|
|
84
|
|
|
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 *>());
|
|
|
89 }
|
|
|
90
|
|
|
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 *>());
|
|
|
96 }
|
|
|
97
|
|
|
98 //===----------------------------------------------------------------------===//
|
|
|
99 // OMPRequiresDecl Implementation.
|
|
|
100 //===----------------------------------------------------------------------===//
|
|
|
101
|
|
|
102 void OMPRequiresDecl::anchor() {}
|
|
|
103
|
|
|
104 OMPRequiresDecl *OMPRequiresDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
105 SourceLocation L,
|
|
|
106 ArrayRef<OMPClause *> CL) {
|
|
|
107 OMPRequiresDecl *D =
|
|
|
108 new (C, DC, additionalSizeToAlloc<OMPClause *>(CL.size()))
|
|
|
109 OMPRequiresDecl(OMPRequires, DC, L);
|
|
|
110 D->NumClauses = CL.size();
|
|
|
111 D->setClauses(CL);
|
|
|
112 return D;
|
|
|
113 }
|
|
|
114
|
|
|
115 OMPRequiresDecl *OMPRequiresDecl::CreateDeserialized(ASTContext &C, unsigned ID,
|
|
|
116 unsigned N) {
|
|
|
117 OMPRequiresDecl *D = new (C, ID, additionalSizeToAlloc<OMPClause *>(N))
|
|
|
118 OMPRequiresDecl(OMPRequires, nullptr, SourceLocation());
|
|
|
119 D->NumClauses = N;
|
|
|
120 return D;
|
|
|
121 }
|
|
|
122
|
|
|
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 *>());
|
|
|
128 }
|
|
|
129
|
|
|
130 //===----------------------------------------------------------------------===//
|
|
|
131 // OMPDeclareReductionDecl Implementation.
|
|
|
132 //===----------------------------------------------------------------------===//
|
|
|
133
|
|
|
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);
|
|
|
140 }
|
|
|
141
|
|
|
142 void OMPDeclareReductionDecl::anchor() {}
|
|
|
143
|
|
|
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,
|
|
|
148 T, PrevDeclInScope);
|
|
|
149 }
|
|
|
150
|
|
|
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);
|
|
|
156 }
|
|
|
157
|
|
|
158 OMPDeclareReductionDecl *OMPDeclareReductionDecl::getPrevDeclInScope() {
|
|
|
159 return cast_or_null<OMPDeclareReductionDecl>(
|
|
|
160 PrevDeclInScope.get(getASTContext().getExternalSource()));
|
|
|
161 }
|
|
|
162 const OMPDeclareReductionDecl *
|
|
|
163 OMPDeclareReductionDecl::getPrevDeclInScope() const {
|
|
|
164 return cast_or_null<OMPDeclareReductionDecl>(
|
|
|
165 PrevDeclInScope.get(getASTContext().getExternalSource()));
|
|
|
166 }
|
|
|
167
|
|
|
168 //===----------------------------------------------------------------------===//
|
|
|
169 // OMPDeclareMapperDecl Implementation.
|
|
|
170 //===----------------------------------------------------------------------===//
|
|
|
171
|
|
|
172 void OMPDeclareMapperDecl::anchor() {}
|
|
|
173
|
|
|
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);
|
|
|
181 }
|
|
|
182
|
|
|
183 OMPDeclareMapperDecl *OMPDeclareMapperDecl::CreateDeserialized(ASTContext &C,
|
|
|
184 unsigned ID,
|
|
|
185 unsigned N) {
|
|
|
186 auto *D = new (C, ID)
|
|
|
187 OMPDeclareMapperDecl(OMPDeclareMapper, /*DC=*/nullptr, SourceLocation(),
|
|
|
188 DeclarationName(), QualType(), DeclarationName(),
|
|
|
189 /*PrevDeclInScope=*/nullptr);
|
|
|
190 if (N) {
|
|
|
191 auto **ClauseStorage = C.Allocate<OMPClause *>(N);
|
|
|
192 D->Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, N);
|
|
|
193 }
|
|
|
194 return D;
|
|
|
195 }
|
|
|
196
|
|
|
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();
|
|
|
205 if (NumClauses) {
|
|
|
206 auto **ClauseStorage = C.Allocate<OMPClause *>(NumClauses);
|
|
|
207 Clauses = llvm::makeMutableArrayRef<OMPClause *>(ClauseStorage, NumClauses);
|
|
|
208 setClauses(CL);
|
|
|
209 }
|
|
|
210 }
|
|
|
211
|
|
|
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());
|
|
|
216 }
|
|
|
217
|
|
|
218 OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() {
|
|
|
219 return cast_or_null<OMPDeclareMapperDecl>(
|
|
|
220 PrevDeclInScope.get(getASTContext().getExternalSource()));
|
|
|
221 }
|
|
|
222
|
|
|
223 const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const {
|
|
|
224 return cast_or_null<OMPDeclareMapperDecl>(
|
|
|
225 PrevDeclInScope.get(getASTContext().getExternalSource()));
|
|
|
226 }
|
|
|
227
|
|
|
228 //===----------------------------------------------------------------------===//
|
|
|
229 // OMPCapturedExprDecl Implementation.
|
|
|
230 //===----------------------------------------------------------------------===//
|
|
|
231
|
|
|
232 void OMPCapturedExprDecl::anchor() {}
|
|
|
233
|
|
|
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);
|
|
|
239 }
|
|
|
240
|
|
|
241 OMPCapturedExprDecl *OMPCapturedExprDecl::CreateDeserialized(ASTContext &C,
|
|
|
242 unsigned ID) {
|
|
|
243 return new (C, ID) OMPCapturedExprDecl(C, nullptr, nullptr, QualType(),
|
|
|
244 /*TInfo=*/nullptr, SourceLocation());
|
|
|
245 }
|
|
|
246
|
|
|
247 SourceRange OMPCapturedExprDecl::getSourceRange() const {
|
|
|
248 assert(hasInit());
|
|
|
249 return SourceRange(getInit()->getBeginLoc(), getInit()->getEndLoc());
|
|
|
250 }
|
