Coverage Report

Created: 2018-07-21 08:31

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/DeclOpenMP.h
Line
Count
Source (jump to first uncovered line)
1
//===- DeclOpenMP.h - Classes for representing OpenMP directives -*- 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
/// \file
11
/// This file defines OpenMP nodes for declarative directives.
12
///
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_AST_DECLOPENMP_H
16
#define LLVM_CLANG_AST_DECLOPENMP_H
17
18
#include "clang/AST/Decl.h"
19
#include "clang/AST/Expr.h"
20
#include "clang/AST/ExternalASTSource.h"
21
#include "clang/AST/Type.h"
22
#include "llvm/ADT/ArrayRef.h"
23
#include "llvm/Support/TrailingObjects.h"
24
25
namespace clang {
26
27
/// This represents '#pragma omp threadprivate ...' directive.
28
/// For example, in the following, both 'a' and 'A::b' are threadprivate:
29
///
30
/// \code
31
/// int a;
32
/// #pragma omp threadprivate(a)
33
/// struct A {
34
///   static int b;
35
/// #pragma omp threadprivate(b)
36
/// };
37
/// \endcode
38
///
39
class OMPThreadPrivateDecl final
40
    : public Decl,
41
      private llvm::TrailingObjects<OMPThreadPrivateDecl, Expr *> {
42
  friend class ASTDeclReader;
43
  friend TrailingObjects;
44
45
  unsigned NumVars;
46
47
  virtual void anchor();
48
49
  OMPThreadPrivateDecl(Kind DK, DeclContext *DC, SourceLocation L) :
50
1.77k
    Decl(DK, DC, L), NumVars(0) { }
51
52
102
  ArrayRef<const Expr *> getVars() const {
53
102
    return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumVars);
54
102
  }
55
56
1.64k
  MutableArrayRef<Expr *> getVars() {
57
1.64k
    return MutableArrayRef<Expr *>(getTrailingObjects<Expr *>(), NumVars);
58
1.64k
  }
59
60
  void setVars(ArrayRef<Expr *> VL);
61
62
public:
63
  static OMPThreadPrivateDecl *Create(ASTContext &C, DeclContext *DC,
64
                                      SourceLocation L,
65
                                      ArrayRef<Expr *> VL);
66
  static OMPThreadPrivateDecl *CreateDeserialized(ASTContext &C,
67
                                                  unsigned ID, unsigned N);
68
69
  typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
70
  typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
71
  typedef llvm::iterator_range<varlist_iterator> varlist_range;
72
  typedef llvm::iterator_range<varlist_const_iterator> varlist_const_range;
73
74
378
  unsigned varlist_size() const { return NumVars; }
75
322
  bool varlist_empty() const { return NumVars == 0; }
76
77
337
  varlist_range varlists() {
78
337
    return varlist_range(varlist_begin(), varlist_end());
79
337
  }
80
51
  varlist_const_range varlists() const {
81
51
    return varlist_const_range(varlist_begin(), varlist_end());
82
51
  }
83
989
  varlist_iterator varlist_begin() { return getVars().begin(); }
84
659
  varlist_iterator varlist_end() { return getVars().end(); }
85
51
  varlist_const_iterator varlist_begin() const { return getVars().begin(); }
86
51
  varlist_const_iterator varlist_end() const { return getVars().end(); }
87
88
459k
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
89
459k
  static bool classofKind(Kind K) { return K == OMPThreadPrivate; }
90
};
91
92
/// This represents '#pragma omp declare reduction ...' directive.
93
/// For example, in the following, declared reduction 'foo' for types 'int' and
94
/// 'float':
95
///
96
/// \code
97
/// #pragma omp declare reduction (foo : int,float : omp_out += omp_in) \
98
///                     initializer (omp_priv = 0)
99
/// \endcode
100
///
101
/// Here 'omp_out += omp_in' is a combiner and 'omp_priv = 0' is an initializer.
102
class OMPDeclareReductionDecl final : public ValueDecl, public DeclContext {
103
public:
104
  enum InitKind {
105
    CallInit,   // Initialized by function call.
106
    DirectInit, // omp_priv(<expr>)
107
    CopyInit    // omp_priv = <expr>
108
  };
109
110
private:
111
  friend class ASTDeclReader;
112
  /// Combiner for declare reduction construct.
113
  Expr *Combiner;
114
  /// Initializer for declare reduction construct.
115
  Expr *Initializer;
116
  /// Kind of initializer - function call or omp_priv<init_expr> initializtion.
117
  InitKind InitializerKind = CallInit;
118
119
  /// Reference to the previous declare reduction construct in the same
120
  /// scope with the same name. Required for proper templates instantiation if
121
  /// the declare reduction construct is declared inside compound statement.
122
  LazyDeclPtr PrevDeclInScope;
123
124
  virtual void anchor();
125
126
  OMPDeclareReductionDecl(Kind DK, DeclContext *DC, SourceLocation L,
127
                          DeclarationName Name, QualType Ty,
128
                          OMPDeclareReductionDecl *PrevDeclInScope)
129
      : ValueDecl(DK, DC, L, Name, Ty), DeclContext(DK), Combiner(nullptr),
130
        Initializer(nullptr), InitializerKind(CallInit),
131
728
        PrevDeclInScope(PrevDeclInScope) {}
132
133
0
  void setPrevDeclInScope(OMPDeclareReductionDecl *Prev) {
134
0
    PrevDeclInScope = Prev;
135
0
  }
136
137
public:
138
  /// Create declare reduction node.
139
  static OMPDeclareReductionDecl *
140
  Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name,
141
         QualType T, OMPDeclareReductionDecl *PrevDeclInScope);
142
  /// Create deserialized declare reduction node.
143
  static OMPDeclareReductionDecl *CreateDeserialized(ASTContext &C,
144
                                                     unsigned ID);
145
146
  /// Get combiner expression of the declare reduction construct.
147
396
  Expr *getCombiner() { return Combiner; }
148
97
  const Expr *getCombiner() const { return Combiner; }
149
  /// Set combiner expression for the declare reduction construct.
150
676
  void setCombiner(Expr *E) { Combiner = E; }
151
152
  /// Get initializer expression (if specified) of the declare reduction
153
  /// construct.
154
556
  Expr *getInitializer() { return Initializer; }
155
195
  const Expr *getInitializer() const { return Initializer; }
156
  /// Get initializer kind.
157
345
  InitKind getInitializerKind() const { return InitializerKind; }
158
  /// Set initializer expression for the declare reduction construct.
159
274
  void setInitializer(Expr *E, InitKind IK) {
160
274
    Initializer = E;
161
274
    InitializerKind = IK;
162
274
  }
163
164
  /// Get reference to previous declare reduction construct in the same
165
  /// scope with the same name.
166
  OMPDeclareReductionDecl *getPrevDeclInScope();
167
  const OMPDeclareReductionDecl *getPrevDeclInScope() const;
168
169
399k
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
170
59.3M
  static bool classofKind(Kind K) { return K == OMPDeclareReduction; }
171
0
  static DeclContext *castToDeclContext(const OMPDeclareReductionDecl *D) {
172
0
    return static_cast<DeclContext *>(const_cast<OMPDeclareReductionDecl *>(D));
173
0
  }
174
0
  static OMPDeclareReductionDecl *castFromDeclContext(const DeclContext *DC) {
175
0
    return static_cast<OMPDeclareReductionDecl *>(
176
0
        const_cast<DeclContext *>(DC));
177
0
  }
178
};
179
180
/// Pseudo declaration for capturing expressions. Also is used for capturing of
181
/// non-static data members in non-static member functions.
182
///
183
/// Clang supports capturing of variables only, but OpenMP 4.5 allows to
184
/// privatize non-static members of current class in non-static member
185
/// functions. This pseudo-declaration allows properly handle this kind of
186
/// capture by wrapping captured expression into a variable-like declaration.
187
class OMPCapturedExprDecl final : public VarDecl {
188
  friend class ASTDeclReader;
189
  void anchor() override;
190
191
  OMPCapturedExprDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
192
                      QualType Type, TypeSourceInfo *TInfo,
193
                      SourceLocation StartLoc)
194
      : VarDecl(OMPCapturedExpr, C, DC, StartLoc, StartLoc, Id, Type, TInfo,
195
37.7k
                SC_None) {
196
37.7k
    setImplicit();
197
37.7k
  }
198
199
public:
200
  static OMPCapturedExprDecl *Create(ASTContext &C, DeclContext *DC,
201
                                     IdentifierInfo *Id, QualType T,
202
                                     SourceLocation StartLoc);
203
204
  static OMPCapturedExprDecl *CreateDeserialized(ASTContext &C, unsigned ID);
205
206
  SourceRange getSourceRange() const override LLVM_READONLY;
207
208
  // Implement isa/cast/dyncast/etc.
209
6.46M
  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
210
6.46M
  static bool classofKind(Kind K) { return K == OMPCapturedExpr; }
211
};
212
213
} // end namespace clang
214
215
#endif