Home | History | Annotate | Line # | Download | only in AST 
      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