clang/lib/AST/DeclOpenMP.cpp

   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, std::nullopt, 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 }