contrib/llvm/tools/clang/include/clang/AST/ExprOpenMP.h

   1 //===--- ExprOpenMP.h - Classes for representing expressions ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the Expr interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_EXPROPENMP_H
  15 #define LLVM_CLANG_AST_EXPROPENMP_H
  16
  17 #include "clang/AST/Expr.h"
  18
  19 namespace clang {
  20 /// OpenMP 4.0 [2.4, Array Sections].
  21 /// To specify an array section in an OpenMP construct, array subscript
  22 /// expressions are extended with the following syntax:
  23 /// \code
  24 /// [ lower-bound : length ]
  25 /// [ lower-bound : ]
  26 /// [ : length ]
  27 /// [ : ]
  28 /// \endcode
  29 /// The array section must be a subset of the original array.
  30 /// Array sections are allowed on multidimensional arrays. Base language array
  31 /// subscript expressions can be used to specify length-one dimensions of
  32 /// multidimensional array sections.
  33 /// The lower-bound and length are integral type expressions. When evaluated
  34 /// they represent a set of integer values as follows:
  35 /// \code
  36 /// { lower-bound, lower-bound + 1, lower-bound + 2,... , lower-bound + length -
  37 /// 1 }
  38 /// \endcode
  39 /// The lower-bound and length must evaluate to non-negative integers.
  40 /// When the size of the array dimension is not known, the length must be
  41 /// specified explicitly.
  42 /// When the length is absent, it defaults to the size of the array dimension
  43 /// minus the lower-bound.
  44 /// When the lower-bound is absent it defaults to 0.
  45 class OMPArraySectionExpr : public Expr {
  46   enum { BASE, LOWER_BOUND, LENGTH, END_EXPR };
  47   Stmt *SubExprs[END_EXPR];
  48   SourceLocation ColonLoc;
  49   SourceLocation RBracketLoc;
  50
  51 public:
  52   OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type,
  53                       ExprValueKind VK, ExprObjectKind OK,
  54                       SourceLocation ColonLoc, SourceLocation RBracketLoc)
  55       : Expr(
  56             OMPArraySectionExprClass, Type, VK, OK,
  57             Base->isTypeDependent() ||
  58                 (LowerBound && LowerBound->isTypeDependent()) ||
  59                 (Length && Length->isTypeDependent()),
  60             Base->isValueDependent() ||
  61                 (LowerBound && LowerBound->isValueDependent()) ||
  62                 (Length && Length->isValueDependent()),
  63             Base->isInstantiationDependent() ||
  64                 (LowerBound && LowerBound->isInstantiationDependent()) ||
  65                 (Length && Length->isInstantiationDependent()),
  66             Base->containsUnexpandedParameterPack() ||
  67                 (LowerBound && LowerBound->containsUnexpandedParameterPack()) ||
  68                 (Length && Length->containsUnexpandedParameterPack())),
  69         ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) {
  70     SubExprs[BASE] = Base;
  71     SubExprs[LOWER_BOUND] = LowerBound;
  72     SubExprs[LENGTH] = Length;
  73   }
  74
  75   /// Create an empty array section expression.
  76   explicit OMPArraySectionExpr(EmptyShell Shell)
  77       : Expr(OMPArraySectionExprClass, Shell) {}
  78
  79   /// An array section can be written only as Base[LowerBound:Length].
  80
  81   /// Get base of the array section.
  82   Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
  83   const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
  84   /// Set base of the array section.
  85   void setBase(Expr *E) { SubExprs[BASE] = E; }
  86
  87   /// Return original type of the base expression for array section.
  88   static QualType getBaseOriginalType(const Expr *Base);
  89
  90   /// Get lower bound of array section.
  91   Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
  92   const Expr *getLowerBound() const {
  93     return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
  94   }
  95   /// Set lower bound of the array section.
  96   void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
  97
  98   /// Get length of array section.
  99   Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
 100   const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
 101   /// Set length of the array section.
 102   void setLength(Expr *E) { SubExprs[LENGTH] = E; }
 103
 104   SourceLocation getLocStart() const LLVM_READONLY { return getBeginLoc(); }
 105   SourceLocation getBeginLoc() const LLVM_READONLY {
 106     return getBase()->getLocStart();
 107   }
 108   SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
 109   SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }
 110
 111   SourceLocation getColonLoc() const { return ColonLoc; }
 112   void setColonLoc(SourceLocation L) { ColonLoc = L; }
 113
 114   SourceLocation getRBracketLoc() const { return RBracketLoc; }
 115   void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
 116
 117   SourceLocation getExprLoc() const LLVM_READONLY {
 118     return getBase()->getExprLoc();
 119   }
 120
 121   static bool classof(const Stmt *T) {
 122     return T->getStmtClass() == OMPArraySectionExprClass;
 123   }
 124
 125   child_range children() {
 126     return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
 127   }
 128 };
 129 } // end namespace clang
 130
 131 #endif