Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/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
/// 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
4.13k
        ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) {
70
4.13k
    SubExprs[BASE] = Base;
71
4.13k
    SubExprs[LOWER_BOUND] = LowerBound;
72
4.13k
    SubExprs[LENGTH] = Length;
73
4.13k
  }
74
75
  /// Create an empty array section expression.
76
  explicit OMPArraySectionExpr(EmptyShell Shell)
77
780
      : 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
8.81k
  Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
83
26.3k
  const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
84
  /// Set base of the array section.
85
780
  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
4.50k
  Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
92
2.78k
  const Expr *getLowerBound() const {
93
2.78k
    return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
94
2.78k
  }
95
  /// Set lower bound of the array section.
96
780
  void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
97
98
  /// Get length of array section.
99
5.21k
  Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
100
6.16k
  const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
101
  /// Set length of the array section.
102
780
  void setLength(Expr *E) { SubExprs[LENGTH] = E; }
103
104
8.62k
  SourceLocation getBeginLoc() const LLVM_READONLY {
105
8.62k
    return getBase()->getBeginLoc();
106
8.62k
  }
107
6.54k
  SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }
108
109
8.20k
  SourceLocation getColonLoc() const { return ColonLoc; }
110
780
  void setColonLoc(SourceLocation L) { ColonLoc = L; }
111
112
2.09k
  SourceLocation getRBracketLoc() const { return RBracketLoc; }
113
780
  void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
114
115
13.2k
  SourceLocation getExprLoc() const LLVM_READONLY {
116
13.2k
    return getBase()->getExprLoc();
117
13.2k
  }
118
119
81.9k
  static bool classof(const Stmt *T) {
120
81.9k
    return T->getStmtClass() == OMPArraySectionExprClass;
121
81.9k
  }
122
123
1.45k
  child_range children() {
124
1.45k
    return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
125
1.45k
  }
126
};
127
} // end namespace clang
128
129
#endif