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