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   auto *D = OMPDeclarativeDirective::createDirective<OMPThreadPrivateDecl>(
33       C, DC, llvm::None, VL.size(), L);
34   D->setVars(VL);
35   return D;
36 }
37 
38 OMPThreadPrivateDecl *OMPThreadPrivateDecl::CreateDeserialized(ASTContext &C,
39                                                                unsigned ID,
40                                                                unsigned N) {
41   return OMPDeclarativeDirective::createEmptyDirective<OMPThreadPrivateDecl>(
42       C, ID, 0, N);
43 }
44 
45 void OMPThreadPrivateDecl::setVars(ArrayRef<Expr *> VL) {
46   assert(VL.size() == Data->getNumChildren() &&
47          "Number of variables is not the same as the preallocated buffer");
48   llvm::copy(VL, getVars().begin());
49 }
50 
51 //===----------------------------------------------------------------------===//
52 // OMPAllocateDecl Implementation.
53 //===----------------------------------------------------------------------===//
54 
55 void OMPAllocateDecl::anchor() { }
56 
57 OMPAllocateDecl *OMPAllocateDecl::Create(ASTContext &C, DeclContext *DC,
58                                          SourceLocation L, ArrayRef<Expr *> VL,
59                                          ArrayRef<OMPClause *> CL) {
60   auto *D = OMPDeclarativeDirective::createDirective<OMPAllocateDecl>(
61       C, DC, CL, VL.size(), L);
62   D->setVars(VL);
63   return D;
64 }
65 
66 OMPAllocateDecl *OMPAllocateDecl::CreateDeserialized(ASTContext &C, unsigned ID,
67                                                      unsigned NVars,
68                                                      unsigned NClauses) {
69   return OMPDeclarativeDirective::createEmptyDirective<OMPAllocateDecl>(
70       C, ID, NClauses, NVars, SourceLocation());
71 }
72 
73 void OMPAllocateDecl::setVars(ArrayRef<Expr *> VL) {
74   assert(VL.size() == Data->getNumChildren() &&
75          "Number of variables is not the same as the preallocated buffer");
76   llvm::copy(VL, getVars().begin());
77 }
78 
79 //===----------------------------------------------------------------------===//
80 // OMPRequiresDecl Implementation.
81 //===----------------------------------------------------------------------===//
82 
83 void OMPRequiresDecl::anchor() {}
84 
85 OMPRequiresDecl *OMPRequiresDecl::Create(ASTContext &C, DeclContext *DC,
86                                          SourceLocation L,
87                                          ArrayRef<OMPClause *> CL) {
88   return OMPDeclarativeDirective::createDirective<OMPRequiresDecl>(C, DC, CL, 0,
89                                                                    L);
90 }
91 
92 OMPRequiresDecl *OMPRequiresDecl::CreateDeserialized(ASTContext &C, unsigned ID,
93                                                      unsigned N) {
94   return OMPDeclarativeDirective::createEmptyDirective<OMPRequiresDecl>(
95       C, ID, N, 0, SourceLocation());
96 }
97 
98 //===----------------------------------------------------------------------===//
99 // OMPDeclareReductionDecl Implementation.
100 //===----------------------------------------------------------------------===//
101 
102 OMPDeclareReductionDecl::OMPDeclareReductionDecl(
103     Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,
104     QualType Ty, OMPDeclareReductionDecl *PrevDeclInScope)
105     : ValueDecl(DK, DC, L, Name, Ty), DeclContext(DK), Combiner(nullptr),
106       PrevDeclInScope(PrevDeclInScope) {
107   setInitializer(nullptr, CallInit);
108 }
109 
110 void OMPDeclareReductionDecl::anchor() {}
111 
112 OMPDeclareReductionDecl *OMPDeclareReductionDecl::Create(
113     ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name,
114     QualType T, OMPDeclareReductionDecl *PrevDeclInScope) {
115   return new (C, DC) OMPDeclareReductionDecl(OMPDeclareReduction, DC, L, Name,
116                                              T, PrevDeclInScope);
117 }
118 
119 OMPDeclareReductionDecl *
120 OMPDeclareReductionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
121   return new (C, ID) OMPDeclareReductionDecl(
122       OMPDeclareReduction, /*DC=*/nullptr, SourceLocation(), DeclarationName(),
123       QualType(), /*PrevDeclInScope=*/nullptr);
124 }
125 
126 OMPDeclareReductionDecl *OMPDeclareReductionDecl::getPrevDeclInScope() {
127   return cast_or_null<OMPDeclareReductionDecl>(
128       PrevDeclInScope.get(getASTContext().getExternalSource()));
129 }
130 const OMPDeclareReductionDecl *
131 OMPDeclareReductionDecl::getPrevDeclInScope() const {
132   return cast_or_null<OMPDeclareReductionDecl>(
133       PrevDeclInScope.get(getASTContext().getExternalSource()));
134 }
135 
136 //===----------------------------------------------------------------------===//
137 // OMPDeclareMapperDecl Implementation.
138 //===----------------------------------------------------------------------===//
139 
140 void OMPDeclareMapperDecl::anchor() {}
141 
142 OMPDeclareMapperDecl *OMPDeclareMapperDecl::Create(
143     ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name,
144     QualType T, DeclarationName VarName, ArrayRef<OMPClause *> Clauses,
145     OMPDeclareMapperDecl *PrevDeclInScope) {
146   return OMPDeclarativeDirective::createDirective<OMPDeclareMapperDecl>(
147       C, DC, Clauses, 1, L, Name, T, VarName, PrevDeclInScope);
148 }
149 
150 OMPDeclareMapperDecl *OMPDeclareMapperDecl::CreateDeserialized(ASTContext &C,
151                                                                unsigned ID,
152                                                                unsigned N) {
153   return OMPDeclarativeDirective::createEmptyDirective<OMPDeclareMapperDecl>(
154       C, ID, N, 1, SourceLocation(), DeclarationName(), QualType(),
155       DeclarationName(), /*PrevDeclInScope=*/nullptr);
156 }
157 
158 OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() {
159   return cast_or_null<OMPDeclareMapperDecl>(
160       PrevDeclInScope.get(getASTContext().getExternalSource()));
161 }
162 
163 const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const {
164   return cast_or_null<OMPDeclareMapperDecl>(
165       PrevDeclInScope.get(getASTContext().getExternalSource()));
166 }
167 
168 //===----------------------------------------------------------------------===//
169 // OMPCapturedExprDecl Implementation.
170 //===----------------------------------------------------------------------===//
171 
172 void OMPCapturedExprDecl::anchor() {}
173 
174 OMPCapturedExprDecl *OMPCapturedExprDecl::Create(ASTContext &C, DeclContext *DC,
175                                                  IdentifierInfo *Id, QualType T,
176                                                  SourceLocation StartLoc) {
177   return new (C, DC) OMPCapturedExprDecl(
178       C, DC, Id, T, C.getTrivialTypeSourceInfo(T), StartLoc);
179 }
180 
181 OMPCapturedExprDecl *OMPCapturedExprDecl::CreateDeserialized(ASTContext &C,
182                                                              unsigned ID) {
183   return new (C, ID) OMPCapturedExprDecl(C, nullptr, nullptr, QualType(),
184                                          /*TInfo=*/nullptr, SourceLocation());
185 }
186 
187 SourceRange OMPCapturedExprDecl::getSourceRange() const {
188   assert(hasInit());
189   return SourceRange(getInit()->getBeginLoc(), getInit()->getEndLoc());
190 }
191