Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/include/clang/AST/ExprOpenMP.h
Line
Count
Source
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
/// \brief 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
1.90k
        ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) {
70
1.90k
    SubExprs[BASE] = Base;
71
1.90k
    SubExprs[LOWER_BOUND] = LowerBound;
72
1.90k
    SubExprs[LENGTH] = Length;
73
1.90k
  }
74
75
  /// \brief Create an empty array section expression.
76
  explicit OMPArraySectionExpr(EmptyShell Shell)
77
362
      : Expr(OMPArraySectionExprClass, Shell) {}
78
79
  /// An array section can be written only as Base[LowerBound:Length].
80
81
  /// \brief Get base of the array section.
82
4.20k
  Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
83
13.5k
  const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
84
  /// \brief Set base of the array section.
85
362
  void setBase(Expr *E) { SubExprs[BASE] = E; }
86
87
  /// \brief Return original type of the base expression for array section.
88
  static QualType getBaseOriginalType(const Expr *Base);
89
90
  /// \brief Get lower bound of array section.
91
2.21k
  Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
92
1.43k
  const Expr *getLowerBound() const {
93
1.43k
    return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
94
1.43k
  }
95
  /// \brief Set lower bound of the array section.
96
362
  void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
97
98
  /// \brief Get length of array section.
99
2.56k
  Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
100
3.24k
  const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
101
  /// \brief Set length of the array section.
102
362
  void setLength(Expr *E) { SubExprs[LENGTH] = E; }
103
104
4.03k
  SourceLocation getLocStart() const LLVM_READONLY {
105
4.03k
    return getBase()->getLocStart();
106
4.03k
  }
107
3.01k
  SourceLocation getLocEnd() const LLVM_READONLY { return RBracketLoc; }
108
109
4.04k
  SourceLocation getColonLoc() const { return ColonLoc; }
110
362
  void setColonLoc(SourceLocation L) { ColonLoc = L; }
111
112
1.01k
  SourceLocation getRBracketLoc() const { return RBracketLoc; }
113
362
  void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
114
115
6.51k
  SourceLocation getExprLoc() const LLVM_READONLY {
116
6.51k
    return getBase()->getExprLoc();
117
6.51k
  }
118
119
38.4k
  static bool classof(const Stmt *T) {
120
38.4k
    return T->getStmtClass() == OMPArraySectionExprClass;
121
38.4k
  }
122
123
212
  child_range children() {
124
212
    return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
125
212
  }
126
};
127
} // end namespace clang
128
129
#endif