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 20using namespace clang; 21 22//===----------------------------------------------------------------------===// 23// OMPThreadPrivateDecl Implementation. 24//===----------------------------------------------------------------------===// 25 26void OMPThreadPrivateDecl::anchor() { } 27 28OMPThreadPrivateDecl *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 40OMPThreadPrivateDecl *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 49void 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 59void OMPAllocateDecl::anchor() { } 60 61OMPAllocateDecl *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 74OMPAllocateDecl *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 85void 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 91void 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 102void OMPRequiresDecl::anchor() {} 103 104OMPRequiresDecl *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 115OMPRequiresDecl *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 123void 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 134OMPDeclareReductionDecl::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 142void OMPDeclareReductionDecl::anchor() {} 143 144OMPDeclareReductionDecl *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 151OMPDeclareReductionDecl * 152OMPDeclareReductionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 153 return new (C, ID) OMPDeclareReductionDecl( 154 OMPDeclareReduction, /*DC=*/nullptr, SourceLocation(), DeclarationName(), 155 QualType(), /*PrevDeclInScope=*/nullptr); 156} 157 158OMPDeclareReductionDecl *OMPDeclareReductionDecl::getPrevDeclInScope() { 159 return cast_or_null<OMPDeclareReductionDecl>( 160 PrevDeclInScope.get(getASTContext().getExternalSource())); 161} 162const OMPDeclareReductionDecl * 163OMPDeclareReductionDecl::getPrevDeclInScope() const { 164 return cast_or_null<OMPDeclareReductionDecl>( 165 PrevDeclInScope.get(getASTContext().getExternalSource())); 166} 167 168//===----------------------------------------------------------------------===// 169// OMPDeclareMapperDecl Implementation. 170//===----------------------------------------------------------------------===// 171 172void OMPDeclareMapperDecl::anchor() {} 173 174OMPDeclareMapperDecl * 175OMPDeclareMapperDecl::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 183OMPDeclareMapperDecl *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 201void 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 212void 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 218OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() { 219 return cast_or_null<OMPDeclareMapperDecl>( 220 PrevDeclInScope.get(getASTContext().getExternalSource())); 221} 222 223const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const { 224 return cast_or_null<OMPDeclareMapperDecl>( 225 PrevDeclInScope.get(getASTContext().getExternalSource())); 226} 227 228//===----------------------------------------------------------------------===// 229// OMPCapturedExprDecl Implementation. 230//===----------------------------------------------------------------------===// 231 232void OMPCapturedExprDecl::anchor() {} 233 234OMPCapturedExprDecl *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 241OMPCapturedExprDecl *OMPCapturedExprDecl::CreateDeserialized(ASTContext &C, 242 unsigned ID) { 243 return new (C, ID) OMPCapturedExprDecl(C, nullptr, nullptr, QualType(), 244 /*TInfo=*/nullptr, SourceLocation()); 245} 246 247SourceRange OMPCapturedExprDecl::getSourceRange() const { 248 assert(hasInit()); 249 return SourceRange(getInit()->getBeginLoc(), getInit()->getEndLoc()); 250} 251