1//===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===// 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// 9/// \file 10/// This file defines OpenMP AST classes for clauses. 11/// There are clauses for executable directives, clauses for declarative 12/// directives and clauses which can be used in both kinds of directives. 13// 14//===----------------------------------------------------------------------===// 15 16#ifndef LLVM_CLANG_AST_OPENMPCLAUSE_H 17#define LLVM_CLANG_AST_OPENMPCLAUSE_H 18 19#include "clang/AST/Decl.h" 20#include "clang/AST/DeclarationName.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/NestedNameSpecifier.h" 23#include "clang/AST/Stmt.h" 24#include "clang/AST/StmtIterator.h" 25#include "clang/Basic/LLVM.h" 26#include "clang/Basic/OpenMPKinds.h" 27#include "clang/Basic/SourceLocation.h" 28#include "llvm/ADT/ArrayRef.h" 29#include "llvm/ADT/MapVector.h" 30#include "llvm/ADT/SmallVector.h" 31#include "llvm/ADT/iterator.h" 32#include "llvm/ADT/iterator_range.h" 33#include "llvm/Frontend/OpenMP/OMPConstants.h" 34#include "llvm/Support/Casting.h" 35#include "llvm/Support/Compiler.h" 36#include "llvm/Support/TrailingObjects.h" 37#include <cassert> 38#include <cstddef> 39#include <iterator> 40#include <utility> 41 42namespace clang { 43 44class ASTContext; 45 46//===----------------------------------------------------------------------===// 47// AST classes for clauses. 48//===----------------------------------------------------------------------===// 49 50/// This is a basic class for representing single OpenMP clause. 51class OMPClause { 52 /// Starting location of the clause (the clause keyword). 53 SourceLocation StartLoc; 54 55 /// Ending location of the clause. 56 SourceLocation EndLoc; 57 58 /// Kind of the clause. 59 OpenMPClauseKind Kind; 60 61protected: 62 OMPClause(OpenMPClauseKind K, SourceLocation StartLoc, SourceLocation EndLoc) 63 : StartLoc(StartLoc), EndLoc(EndLoc), Kind(K) {} 64 65public: 66 /// Returns the starting location of the clause. 67 SourceLocation getBeginLoc() const { return StartLoc; } 68 69 /// Returns the ending location of the clause. 70 SourceLocation getEndLoc() const { return EndLoc; } 71 72 /// Sets the starting location of the clause. 73 void setLocStart(SourceLocation Loc) { StartLoc = Loc; } 74 75 /// Sets the ending location of the clause. 76 void setLocEnd(SourceLocation Loc) { EndLoc = Loc; } 77 78 /// Returns kind of OpenMP clause (private, shared, reduction, etc.). 79 OpenMPClauseKind getClauseKind() const { return Kind; } 80 81 bool isImplicit() const { return StartLoc.isInvalid(); } 82 83 using child_iterator = StmtIterator; 84 using const_child_iterator = ConstStmtIterator; 85 using child_range = llvm::iterator_range<child_iterator>; 86 using const_child_range = llvm::iterator_range<const_child_iterator>; 87 88 child_range children(); 89 const_child_range children() const { 90 auto Children = const_cast<OMPClause *>(this)->children(); 91 return const_child_range(Children.begin(), Children.end()); 92 } 93 94 /// Get the iterator range for the expressions used in the clauses. Used 95 /// expressions include only the children that must be evaluated at the 96 /// runtime before entering the construct. 97 child_range used_children(); 98 const_child_range used_children() const { 99 auto Children = const_cast<OMPClause *>(this)->children(); 100 return const_child_range(Children.begin(), Children.end()); 101 } 102 103 static bool classof(const OMPClause *) { return true; } 104}; 105 106/// Class that handles pre-initialization statement for some clauses, like 107/// 'shedule', 'firstprivate' etc. 108class OMPClauseWithPreInit { 109 friend class OMPClauseReader; 110 111 /// Pre-initialization statement for the clause. 112 Stmt *PreInit = nullptr; 113 114 /// Region that captures the associated stmt. 115 OpenMPDirectiveKind CaptureRegion = llvm::omp::OMPD_unknown; 116 117protected: 118 OMPClauseWithPreInit(const OMPClause *This) { 119 assert(get(This) && "get is not tuned for pre-init."); 120 } 121 122 /// Set pre-initialization statement for the clause. 123 void 124 setPreInitStmt(Stmt *S, 125 OpenMPDirectiveKind ThisRegion = llvm::omp::OMPD_unknown) { 126 PreInit = S; 127 CaptureRegion = ThisRegion; 128 } 129 130public: 131 /// Get pre-initialization statement for the clause. 132 const Stmt *getPreInitStmt() const { return PreInit; } 133 134 /// Get pre-initialization statement for the clause. 135 Stmt *getPreInitStmt() { return PreInit; } 136 137 /// Get capture region for the stmt in the clause. 138 OpenMPDirectiveKind getCaptureRegion() const { return CaptureRegion; } 139 140 static OMPClauseWithPreInit *get(OMPClause *C); 141 static const OMPClauseWithPreInit *get(const OMPClause *C); 142}; 143 144/// Class that handles post-update expression for some clauses, like 145/// 'lastprivate', 'reduction' etc. 146class OMPClauseWithPostUpdate : public OMPClauseWithPreInit { 147 friend class OMPClauseReader; 148 149 /// Post-update expression for the clause. 150 Expr *PostUpdate = nullptr; 151 152protected: 153 OMPClauseWithPostUpdate(const OMPClause *This) : OMPClauseWithPreInit(This) { 154 assert(get(This) && "get is not tuned for post-update."); 155 } 156 157 /// Set pre-initialization statement for the clause. 158 void setPostUpdateExpr(Expr *S) { PostUpdate = S; } 159 160public: 161 /// Get post-update expression for the clause. 162 const Expr *getPostUpdateExpr() const { return PostUpdate; } 163 164 /// Get post-update expression for the clause. 165 Expr *getPostUpdateExpr() { return PostUpdate; } 166 167 static OMPClauseWithPostUpdate *get(OMPClause *C); 168 static const OMPClauseWithPostUpdate *get(const OMPClause *C); 169}; 170 171/// This structure contains most locations needed for by an OMPVarListClause. 172struct OMPVarListLocTy { 173 /// Starting location of the clause (the clause keyword). 174 SourceLocation StartLoc; 175 /// Location of '('. 176 SourceLocation LParenLoc; 177 /// Ending location of the clause. 178 SourceLocation EndLoc; 179 OMPVarListLocTy() = default; 180 OMPVarListLocTy(SourceLocation StartLoc, SourceLocation LParenLoc, 181 SourceLocation EndLoc) 182 : StartLoc(StartLoc), LParenLoc(LParenLoc), EndLoc(EndLoc) {} 183}; 184 185/// This represents clauses with the list of variables like 'private', 186/// 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the 187/// '#pragma omp ...' directives. 188template <class T> class OMPVarListClause : public OMPClause { 189 friend class OMPClauseReader; 190 191 /// Location of '('. 192 SourceLocation LParenLoc; 193 194 /// Number of variables in the list. 195 unsigned NumVars; 196 197protected: 198 /// Build a clause with \a N variables 199 /// 200 /// \param K Kind of the clause. 201 /// \param StartLoc Starting location of the clause (the clause keyword). 202 /// \param LParenLoc Location of '('. 203 /// \param EndLoc Ending location of the clause. 204 /// \param N Number of the variables in the clause. 205 OMPVarListClause(OpenMPClauseKind K, SourceLocation StartLoc, 206 SourceLocation LParenLoc, SourceLocation EndLoc, unsigned N) 207 : OMPClause(K, StartLoc, EndLoc), LParenLoc(LParenLoc), NumVars(N) {} 208 209 /// Fetches list of variables associated with this clause. 210 MutableArrayRef<Expr *> getVarRefs() { 211 return MutableArrayRef<Expr *>( 212 static_cast<T *>(this)->template getTrailingObjects<Expr *>(), NumVars); 213 } 214 215 /// Sets the list of variables for this clause. 216 void setVarRefs(ArrayRef<Expr *> VL) { 217 assert(VL.size() == NumVars && 218 "Number of variables is not the same as the preallocated buffer"); 219 std::copy(VL.begin(), VL.end(), 220 static_cast<T *>(this)->template getTrailingObjects<Expr *>()); 221 } 222 223public: 224 using varlist_iterator = MutableArrayRef<Expr *>::iterator; 225 using varlist_const_iterator = ArrayRef<const Expr *>::iterator; 226 using varlist_range = llvm::iterator_range<varlist_iterator>; 227 using varlist_const_range = llvm::iterator_range<varlist_const_iterator>; 228 229 unsigned varlist_size() const { return NumVars; } 230 bool varlist_empty() const { return NumVars == 0; } 231 232 varlist_range varlists() { 233 return varlist_range(varlist_begin(), varlist_end()); 234 } 235 varlist_const_range varlists() const { 236 return varlist_const_range(varlist_begin(), varlist_end()); 237 } 238 239 varlist_iterator varlist_begin() { return getVarRefs().begin(); } 240 varlist_iterator varlist_end() { return getVarRefs().end(); } 241 varlist_const_iterator varlist_begin() const { return getVarRefs().begin(); } 242 varlist_const_iterator varlist_end() const { return getVarRefs().end(); } 243 244 /// Sets the location of '('. 245 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 246 247 /// Returns the location of '('. 248 SourceLocation getLParenLoc() const { return LParenLoc; } 249 250 /// Fetches list of all variables in the clause. 251 ArrayRef<const Expr *> getVarRefs() const { 252 return llvm::makeArrayRef( 253 static_cast<const T *>(this)->template getTrailingObjects<Expr *>(), 254 NumVars); 255 } 256}; 257 258/// This represents 'allocator' clause in the '#pragma omp ...' 259/// directive. 260/// 261/// \code 262/// #pragma omp allocate(a) allocator(omp_default_mem_alloc) 263/// \endcode 264/// In this example directive '#pragma omp allocate' has simple 'allocator' 265/// clause with the allocator 'omp_default_mem_alloc'. 266class OMPAllocatorClause : public OMPClause { 267 friend class OMPClauseReader; 268 269 /// Location of '('. 270 SourceLocation LParenLoc; 271 272 /// Expression with the allocator. 273 Stmt *Allocator = nullptr; 274 275 /// Set allocator. 276 void setAllocator(Expr *A) { Allocator = A; } 277 278public: 279 /// Build 'allocator' clause with the given allocator. 280 /// 281 /// \param A Allocator. 282 /// \param StartLoc Starting location of the clause. 283 /// \param LParenLoc Location of '('. 284 /// \param EndLoc Ending location of the clause. 285 OMPAllocatorClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc, 286 SourceLocation EndLoc) 287 : OMPClause(OMPC_allocator, StartLoc, EndLoc), LParenLoc(LParenLoc), 288 Allocator(A) {} 289 290 /// Build an empty clause. 291 OMPAllocatorClause() 292 : OMPClause(OMPC_allocator, SourceLocation(), SourceLocation()) {} 293 294 /// Sets the location of '('. 295 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 296 297 /// Returns the location of '('. 298 SourceLocation getLParenLoc() const { return LParenLoc; } 299 300 /// Returns allocator. 301 Expr *getAllocator() const { return cast_or_null<Expr>(Allocator); } 302 303 child_range children() { return child_range(&Allocator, &Allocator + 1); } 304 305 const_child_range children() const { 306 return const_child_range(&Allocator, &Allocator + 1); 307 } 308 309 child_range used_children() { 310 return child_range(child_iterator(), child_iterator()); 311 } 312 const_child_range used_children() const { 313 return const_child_range(const_child_iterator(), const_child_iterator()); 314 } 315 316 static bool classof(const OMPClause *T) { 317 return T->getClauseKind() == OMPC_allocator; 318 } 319}; 320 321/// This represents clause 'allocate' in the '#pragma omp ...' directives. 322/// 323/// \code 324/// #pragma omp parallel private(a) allocate(omp_default_mem_alloc :a) 325/// \endcode 326/// In this example directive '#pragma omp parallel' has clause 'private' 327/// and clause 'allocate' for the variable 'a'. 328class OMPAllocateClause final 329 : public OMPVarListClause<OMPAllocateClause>, 330 private llvm::TrailingObjects<OMPAllocateClause, Expr *> { 331 friend class OMPClauseReader; 332 friend OMPVarListClause; 333 friend TrailingObjects; 334 335 /// Allocator specified in the clause, or 'nullptr' if the default one is 336 /// used. 337 Expr *Allocator = nullptr; 338 /// Position of the ':' delimiter in the clause; 339 SourceLocation ColonLoc; 340 341 /// Build clause with number of variables \a N. 342 /// 343 /// \param StartLoc Starting location of the clause. 344 /// \param LParenLoc Location of '('. 345 /// \param Allocator Allocator expression. 346 /// \param ColonLoc Location of ':' delimiter. 347 /// \param EndLoc Ending location of the clause. 348 /// \param N Number of the variables in the clause. 349 OMPAllocateClause(SourceLocation StartLoc, SourceLocation LParenLoc, 350 Expr *Allocator, SourceLocation ColonLoc, 351 SourceLocation EndLoc, unsigned N) 352 : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, StartLoc, LParenLoc, 353 EndLoc, N), 354 Allocator(Allocator), ColonLoc(ColonLoc) {} 355 356 /// Build an empty clause. 357 /// 358 /// \param N Number of variables. 359 explicit OMPAllocateClause(unsigned N) 360 : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, SourceLocation(), 361 SourceLocation(), SourceLocation(), 362 N) {} 363 364 /// Sets location of ':' symbol in clause. 365 void setColonLoc(SourceLocation CL) { ColonLoc = CL; } 366 367 void setAllocator(Expr *A) { Allocator = A; } 368 369public: 370 /// Creates clause with a list of variables \a VL. 371 /// 372 /// \param C AST context. 373 /// \param StartLoc Starting location of the clause. 374 /// \param LParenLoc Location of '('. 375 /// \param Allocator Allocator expression. 376 /// \param ColonLoc Location of ':' delimiter. 377 /// \param EndLoc Ending location of the clause. 378 /// \param VL List of references to the variables. 379 static OMPAllocateClause *Create(const ASTContext &C, SourceLocation StartLoc, 380 SourceLocation LParenLoc, Expr *Allocator, 381 SourceLocation ColonLoc, 382 SourceLocation EndLoc, ArrayRef<Expr *> VL); 383 384 /// Returns the allocator expression or nullptr, if no allocator is specified. 385 Expr *getAllocator() const { return Allocator; } 386 387 /// Returns the location of the ':' delimiter. 388 SourceLocation getColonLoc() const { return ColonLoc; } 389 390 /// Creates an empty clause with the place for \a N variables. 391 /// 392 /// \param C AST context. 393 /// \param N The number of variables. 394 static OMPAllocateClause *CreateEmpty(const ASTContext &C, unsigned N); 395 396 child_range children() { 397 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 398 reinterpret_cast<Stmt **>(varlist_end())); 399 } 400 401 const_child_range children() const { 402 auto Children = const_cast<OMPAllocateClause *>(this)->children(); 403 return const_child_range(Children.begin(), Children.end()); 404 } 405 406 child_range used_children() { 407 return child_range(child_iterator(), child_iterator()); 408 } 409 const_child_range used_children() const { 410 return const_child_range(const_child_iterator(), const_child_iterator()); 411 } 412 413 static bool classof(const OMPClause *T) { 414 return T->getClauseKind() == OMPC_allocate; 415 } 416}; 417 418/// This represents 'if' clause in the '#pragma omp ...' directive. 419/// 420/// \code 421/// #pragma omp parallel if(parallel:a > 5) 422/// \endcode 423/// In this example directive '#pragma omp parallel' has simple 'if' clause with 424/// condition 'a > 5' and directive name modifier 'parallel'. 425class OMPIfClause : public OMPClause, public OMPClauseWithPreInit { 426 friend class OMPClauseReader; 427 428 /// Location of '('. 429 SourceLocation LParenLoc; 430 431 /// Condition of the 'if' clause. 432 Stmt *Condition = nullptr; 433 434 /// Location of ':' (if any). 435 SourceLocation ColonLoc; 436 437 /// Directive name modifier for the clause. 438 OpenMPDirectiveKind NameModifier = llvm::omp::OMPD_unknown; 439 440 /// Name modifier location. 441 SourceLocation NameModifierLoc; 442 443 /// Set condition. 444 void setCondition(Expr *Cond) { Condition = Cond; } 445 446 /// Set directive name modifier for the clause. 447 void setNameModifier(OpenMPDirectiveKind NM) { NameModifier = NM; } 448 449 /// Set location of directive name modifier for the clause. 450 void setNameModifierLoc(SourceLocation Loc) { NameModifierLoc = Loc; } 451 452 /// Set location of ':'. 453 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 454 455public: 456 /// Build 'if' clause with condition \a Cond. 457 /// 458 /// \param NameModifier [OpenMP 4.1] Directive name modifier of clause. 459 /// \param Cond Condition of the clause. 460 /// \param HelperCond Helper condition for the clause. 461 /// \param CaptureRegion Innermost OpenMP region where expressions in this 462 /// clause must be captured. 463 /// \param StartLoc Starting location of the clause. 464 /// \param LParenLoc Location of '('. 465 /// \param NameModifierLoc Location of directive name modifier. 466 /// \param ColonLoc [OpenMP 4.1] Location of ':'. 467 /// \param EndLoc Ending location of the clause. 468 OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond, 469 OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, 470 SourceLocation LParenLoc, SourceLocation NameModifierLoc, 471 SourceLocation ColonLoc, SourceLocation EndLoc) 472 : OMPClause(OMPC_if, StartLoc, EndLoc), OMPClauseWithPreInit(this), 473 LParenLoc(LParenLoc), Condition(Cond), ColonLoc(ColonLoc), 474 NameModifier(NameModifier), NameModifierLoc(NameModifierLoc) { 475 setPreInitStmt(HelperCond, CaptureRegion); 476 } 477 478 /// Build an empty clause. 479 OMPIfClause() 480 : OMPClause(OMPC_if, SourceLocation(), SourceLocation()), 481 OMPClauseWithPreInit(this) {} 482 483 /// Sets the location of '('. 484 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 485 486 /// Returns the location of '('. 487 SourceLocation getLParenLoc() const { return LParenLoc; } 488 489 /// Return the location of ':'. 490 SourceLocation getColonLoc() const { return ColonLoc; } 491 492 /// Returns condition. 493 Expr *getCondition() const { return cast_or_null<Expr>(Condition); } 494 495 /// Return directive name modifier associated with the clause. 496 OpenMPDirectiveKind getNameModifier() const { return NameModifier; } 497 498 /// Return the location of directive name modifier. 499 SourceLocation getNameModifierLoc() const { return NameModifierLoc; } 500 501 child_range children() { return child_range(&Condition, &Condition + 1); } 502 503 const_child_range children() const { 504 return const_child_range(&Condition, &Condition + 1); 505 } 506 507 child_range used_children(); 508 const_child_range used_children() const { 509 auto Children = const_cast<OMPIfClause *>(this)->used_children(); 510 return const_child_range(Children.begin(), Children.end()); 511 } 512 513 static bool classof(const OMPClause *T) { 514 return T->getClauseKind() == OMPC_if; 515 } 516}; 517 518/// This represents 'final' clause in the '#pragma omp ...' directive. 519/// 520/// \code 521/// #pragma omp task final(a > 5) 522/// \endcode 523/// In this example directive '#pragma omp task' has simple 'final' 524/// clause with condition 'a > 5'. 525class OMPFinalClause : public OMPClause, public OMPClauseWithPreInit { 526 friend class OMPClauseReader; 527 528 /// Location of '('. 529 SourceLocation LParenLoc; 530 531 /// Condition of the 'if' clause. 532 Stmt *Condition = nullptr; 533 534 /// Set condition. 535 void setCondition(Expr *Cond) { Condition = Cond; } 536 537public: 538 /// Build 'final' clause with condition \a Cond. 539 /// 540 /// \param Cond Condition of the clause. 541 /// \param HelperCond Helper condition for the construct. 542 /// \param CaptureRegion Innermost OpenMP region where expressions in this 543 /// clause must be captured. 544 /// \param StartLoc Starting location of the clause. 545 /// \param LParenLoc Location of '('. 546 /// \param EndLoc Ending location of the clause. 547 OMPFinalClause(Expr *Cond, Stmt *HelperCond, 548 OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, 549 SourceLocation LParenLoc, SourceLocation EndLoc) 550 : OMPClause(OMPC_final, StartLoc, EndLoc), OMPClauseWithPreInit(this), 551 LParenLoc(LParenLoc), Condition(Cond) { 552 setPreInitStmt(HelperCond, CaptureRegion); 553 } 554 555 /// Build an empty clause. 556 OMPFinalClause() 557 : OMPClause(OMPC_final, SourceLocation(), SourceLocation()), 558 OMPClauseWithPreInit(this) {} 559 560 /// Sets the location of '('. 561 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 562 563 /// Returns the location of '('. 564 SourceLocation getLParenLoc() const { return LParenLoc; } 565 566 /// Returns condition. 567 Expr *getCondition() const { return cast_or_null<Expr>(Condition); } 568 569 child_range children() { return child_range(&Condition, &Condition + 1); } 570 571 const_child_range children() const { 572 return const_child_range(&Condition, &Condition + 1); 573 } 574 575 child_range used_children(); 576 const_child_range used_children() const { 577 auto Children = const_cast<OMPFinalClause *>(this)->used_children(); 578 return const_child_range(Children.begin(), Children.end()); 579 } 580 581 static bool classof(const OMPClause *T) { 582 return T->getClauseKind() == OMPC_final; 583 } 584}; 585 586/// This represents 'num_threads' clause in the '#pragma omp ...' 587/// directive. 588/// 589/// \code 590/// #pragma omp parallel num_threads(6) 591/// \endcode 592/// In this example directive '#pragma omp parallel' has simple 'num_threads' 593/// clause with number of threads '6'. 594class OMPNumThreadsClause : public OMPClause, public OMPClauseWithPreInit { 595 friend class OMPClauseReader; 596 597 /// Location of '('. 598 SourceLocation LParenLoc; 599 600 /// Condition of the 'num_threads' clause. 601 Stmt *NumThreads = nullptr; 602 603 /// Set condition. 604 void setNumThreads(Expr *NThreads) { NumThreads = NThreads; } 605 606public: 607 /// Build 'num_threads' clause with condition \a NumThreads. 608 /// 609 /// \param NumThreads Number of threads for the construct. 610 /// \param HelperNumThreads Helper Number of threads for the construct. 611 /// \param CaptureRegion Innermost OpenMP region where expressions in this 612 /// clause must be captured. 613 /// \param StartLoc Starting location of the clause. 614 /// \param LParenLoc Location of '('. 615 /// \param EndLoc Ending location of the clause. 616 OMPNumThreadsClause(Expr *NumThreads, Stmt *HelperNumThreads, 617 OpenMPDirectiveKind CaptureRegion, 618 SourceLocation StartLoc, SourceLocation LParenLoc, 619 SourceLocation EndLoc) 620 : OMPClause(OMPC_num_threads, StartLoc, EndLoc), 621 OMPClauseWithPreInit(this), LParenLoc(LParenLoc), 622 NumThreads(NumThreads) { 623 setPreInitStmt(HelperNumThreads, CaptureRegion); 624 } 625 626 /// Build an empty clause. 627 OMPNumThreadsClause() 628 : OMPClause(OMPC_num_threads, SourceLocation(), SourceLocation()), 629 OMPClauseWithPreInit(this) {} 630 631 /// Sets the location of '('. 632 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 633 634 /// Returns the location of '('. 635 SourceLocation getLParenLoc() const { return LParenLoc; } 636 637 /// Returns number of threads. 638 Expr *getNumThreads() const { return cast_or_null<Expr>(NumThreads); } 639 640 child_range children() { return child_range(&NumThreads, &NumThreads + 1); } 641 642 const_child_range children() const { 643 return const_child_range(&NumThreads, &NumThreads + 1); 644 } 645 646 child_range used_children() { 647 return child_range(child_iterator(), child_iterator()); 648 } 649 const_child_range used_children() const { 650 return const_child_range(const_child_iterator(), const_child_iterator()); 651 } 652 653 static bool classof(const OMPClause *T) { 654 return T->getClauseKind() == OMPC_num_threads; 655 } 656}; 657 658/// This represents 'safelen' clause in the '#pragma omp ...' 659/// directive. 660/// 661/// \code 662/// #pragma omp simd safelen(4) 663/// \endcode 664/// In this example directive '#pragma omp simd' has clause 'safelen' 665/// with single expression '4'. 666/// If the safelen clause is used then no two iterations executed 667/// concurrently with SIMD instructions can have a greater distance 668/// in the logical iteration space than its value. The parameter of 669/// the safelen clause must be a constant positive integer expression. 670class OMPSafelenClause : public OMPClause { 671 friend class OMPClauseReader; 672 673 /// Location of '('. 674 SourceLocation LParenLoc; 675 676 /// Safe iteration space distance. 677 Stmt *Safelen = nullptr; 678 679 /// Set safelen. 680 void setSafelen(Expr *Len) { Safelen = Len; } 681 682public: 683 /// Build 'safelen' clause. 684 /// 685 /// \param Len Expression associated with this clause. 686 /// \param StartLoc Starting location of the clause. 687 /// \param EndLoc Ending location of the clause. 688 OMPSafelenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc, 689 SourceLocation EndLoc) 690 : OMPClause(OMPC_safelen, StartLoc, EndLoc), LParenLoc(LParenLoc), 691 Safelen(Len) {} 692 693 /// Build an empty clause. 694 explicit OMPSafelenClause() 695 : OMPClause(OMPC_safelen, SourceLocation(), SourceLocation()) {} 696 697 /// Sets the location of '('. 698 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 699 700 /// Returns the location of '('. 701 SourceLocation getLParenLoc() const { return LParenLoc; } 702 703 /// Return safe iteration space distance. 704 Expr *getSafelen() const { return cast_or_null<Expr>(Safelen); } 705 706 child_range children() { return child_range(&Safelen, &Safelen + 1); } 707 708 const_child_range children() const { 709 return const_child_range(&Safelen, &Safelen + 1); 710 } 711 712 child_range used_children() { 713 return child_range(child_iterator(), child_iterator()); 714 } 715 const_child_range used_children() const { 716 return const_child_range(const_child_iterator(), const_child_iterator()); 717 } 718 719 static bool classof(const OMPClause *T) { 720 return T->getClauseKind() == OMPC_safelen; 721 } 722}; 723 724/// This represents 'simdlen' clause in the '#pragma omp ...' 725/// directive. 726/// 727/// \code 728/// #pragma omp simd simdlen(4) 729/// \endcode 730/// In this example directive '#pragma omp simd' has clause 'simdlen' 731/// with single expression '4'. 732/// If the 'simdlen' clause is used then it specifies the preferred number of 733/// iterations to be executed concurrently. The parameter of the 'simdlen' 734/// clause must be a constant positive integer expression. 735class OMPSimdlenClause : public OMPClause { 736 friend class OMPClauseReader; 737 738 /// Location of '('. 739 SourceLocation LParenLoc; 740 741 /// Safe iteration space distance. 742 Stmt *Simdlen = nullptr; 743 744 /// Set simdlen. 745 void setSimdlen(Expr *Len) { Simdlen = Len; } 746 747public: 748 /// Build 'simdlen' clause. 749 /// 750 /// \param Len Expression associated with this clause. 751 /// \param StartLoc Starting location of the clause. 752 /// \param EndLoc Ending location of the clause. 753 OMPSimdlenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc, 754 SourceLocation EndLoc) 755 : OMPClause(OMPC_simdlen, StartLoc, EndLoc), LParenLoc(LParenLoc), 756 Simdlen(Len) {} 757 758 /// Build an empty clause. 759 explicit OMPSimdlenClause() 760 : OMPClause(OMPC_simdlen, SourceLocation(), SourceLocation()) {} 761 762 /// Sets the location of '('. 763 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 764 765 /// Returns the location of '('. 766 SourceLocation getLParenLoc() const { return LParenLoc; } 767 768 /// Return safe iteration space distance. 769 Expr *getSimdlen() const { return cast_or_null<Expr>(Simdlen); } 770 771 child_range children() { return child_range(&Simdlen, &Simdlen + 1); } 772 773 const_child_range children() const { 774 return const_child_range(&Simdlen, &Simdlen + 1); 775 } 776 777 child_range used_children() { 778 return child_range(child_iterator(), child_iterator()); 779 } 780 const_child_range used_children() const { 781 return const_child_range(const_child_iterator(), const_child_iterator()); 782 } 783 784 static bool classof(const OMPClause *T) { 785 return T->getClauseKind() == OMPC_simdlen; 786 } 787}; 788 789/// This represents 'collapse' clause in the '#pragma omp ...' 790/// directive. 791/// 792/// \code 793/// #pragma omp simd collapse(3) 794/// \endcode 795/// In this example directive '#pragma omp simd' has clause 'collapse' 796/// with single expression '3'. 797/// The parameter must be a constant positive integer expression, it specifies 798/// the number of nested loops that should be collapsed into a single iteration 799/// space. 800class OMPCollapseClause : public OMPClause { 801 friend class OMPClauseReader; 802 803 /// Location of '('. 804 SourceLocation LParenLoc; 805 806 /// Number of for-loops. 807 Stmt *NumForLoops = nullptr; 808 809 /// Set the number of associated for-loops. 810 void setNumForLoops(Expr *Num) { NumForLoops = Num; } 811 812public: 813 /// Build 'collapse' clause. 814 /// 815 /// \param Num Expression associated with this clause. 816 /// \param StartLoc Starting location of the clause. 817 /// \param LParenLoc Location of '('. 818 /// \param EndLoc Ending location of the clause. 819 OMPCollapseClause(Expr *Num, SourceLocation StartLoc, 820 SourceLocation LParenLoc, SourceLocation EndLoc) 821 : OMPClause(OMPC_collapse, StartLoc, EndLoc), LParenLoc(LParenLoc), 822 NumForLoops(Num) {} 823 824 /// Build an empty clause. 825 explicit OMPCollapseClause() 826 : OMPClause(OMPC_collapse, SourceLocation(), SourceLocation()) {} 827 828 /// Sets the location of '('. 829 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 830 831 /// Returns the location of '('. 832 SourceLocation getLParenLoc() const { return LParenLoc; } 833 834 /// Return the number of associated for-loops. 835 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); } 836 837 child_range children() { return child_range(&NumForLoops, &NumForLoops + 1); } 838 839 const_child_range children() const { 840 return const_child_range(&NumForLoops, &NumForLoops + 1); 841 } 842 843 child_range used_children() { 844 return child_range(child_iterator(), child_iterator()); 845 } 846 const_child_range used_children() const { 847 return const_child_range(const_child_iterator(), const_child_iterator()); 848 } 849 850 static bool classof(const OMPClause *T) { 851 return T->getClauseKind() == OMPC_collapse; 852 } 853}; 854 855/// This represents 'default' clause in the '#pragma omp ...' directive. 856/// 857/// \code 858/// #pragma omp parallel default(shared) 859/// \endcode 860/// In this example directive '#pragma omp parallel' has simple 'default' 861/// clause with kind 'shared'. 862class OMPDefaultClause : public OMPClause { 863 friend class OMPClauseReader; 864 865 /// Location of '('. 866 SourceLocation LParenLoc; 867 868 /// A kind of the 'default' clause. 869 OpenMPDefaultClauseKind Kind = OMPC_DEFAULT_unknown; 870 871 /// Start location of the kind in source code. 872 SourceLocation KindKwLoc; 873 874 /// Set kind of the clauses. 875 /// 876 /// \param K Argument of clause. 877 void setDefaultKind(OpenMPDefaultClauseKind K) { Kind = K; } 878 879 /// Set argument location. 880 /// 881 /// \param KLoc Argument location. 882 void setDefaultKindKwLoc(SourceLocation KLoc) { KindKwLoc = KLoc; } 883 884public: 885 /// Build 'default' clause with argument \a A ('none' or 'shared'). 886 /// 887 /// \param A Argument of the clause ('none' or 'shared'). 888 /// \param ALoc Starting location of the argument. 889 /// \param StartLoc Starting location of the clause. 890 /// \param LParenLoc Location of '('. 891 /// \param EndLoc Ending location of the clause. 892 OMPDefaultClause(OpenMPDefaultClauseKind A, SourceLocation ALoc, 893 SourceLocation StartLoc, SourceLocation LParenLoc, 894 SourceLocation EndLoc) 895 : OMPClause(OMPC_default, StartLoc, EndLoc), LParenLoc(LParenLoc), 896 Kind(A), KindKwLoc(ALoc) {} 897 898 /// Build an empty clause. 899 OMPDefaultClause() 900 : OMPClause(OMPC_default, SourceLocation(), SourceLocation()) {} 901 902 /// Sets the location of '('. 903 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 904 905 /// Returns the location of '('. 906 SourceLocation getLParenLoc() const { return LParenLoc; } 907 908 /// Returns kind of the clause. 909 OpenMPDefaultClauseKind getDefaultKind() const { return Kind; } 910 911 /// Returns location of clause kind. 912 SourceLocation getDefaultKindKwLoc() const { return KindKwLoc; } 913 914 child_range children() { 915 return child_range(child_iterator(), child_iterator()); 916 } 917 918 const_child_range children() const { 919 return const_child_range(const_child_iterator(), const_child_iterator()); 920 } 921 922 child_range used_children() { 923 return child_range(child_iterator(), child_iterator()); 924 } 925 const_child_range used_children() const { 926 return const_child_range(const_child_iterator(), const_child_iterator()); 927 } 928 929 static bool classof(const OMPClause *T) { 930 return T->getClauseKind() == OMPC_default; 931 } 932}; 933 934/// This represents 'proc_bind' clause in the '#pragma omp ...' 935/// directive. 936/// 937/// \code 938/// #pragma omp parallel proc_bind(master) 939/// \endcode 940/// In this example directive '#pragma omp parallel' has simple 'proc_bind' 941/// clause with kind 'master'. 942class OMPProcBindClause : public OMPClause { 943 friend class OMPClauseReader; 944 945 /// Location of '('. 946 SourceLocation LParenLoc; 947 948 /// A kind of the 'proc_bind' clause. 949 llvm::omp::ProcBindKind Kind = llvm::omp::OMP_PROC_BIND_unknown; 950 951 /// Start location of the kind in source code. 952 SourceLocation KindKwLoc; 953 954 /// Set kind of the clause. 955 /// 956 /// \param K Kind of clause. 957 void setProcBindKind(llvm::omp::ProcBindKind K) { Kind = K; } 958 959 /// Set clause kind location. 960 /// 961 /// \param KLoc Kind location. 962 void setProcBindKindKwLoc(SourceLocation KLoc) { KindKwLoc = KLoc; } 963 964public: 965 /// Build 'proc_bind' clause with argument \a A ('master', 'close' or 966 /// 'spread'). 967 /// 968 /// \param A Argument of the clause ('master', 'close' or 'spread'). 969 /// \param ALoc Starting location of the argument. 970 /// \param StartLoc Starting location of the clause. 971 /// \param LParenLoc Location of '('. 972 /// \param EndLoc Ending location of the clause. 973 OMPProcBindClause(llvm::omp::ProcBindKind A, SourceLocation ALoc, 974 SourceLocation StartLoc, SourceLocation LParenLoc, 975 SourceLocation EndLoc) 976 : OMPClause(OMPC_proc_bind, StartLoc, EndLoc), LParenLoc(LParenLoc), 977 Kind(A), KindKwLoc(ALoc) {} 978 979 /// Build an empty clause. 980 OMPProcBindClause() 981 : OMPClause(OMPC_proc_bind, SourceLocation(), SourceLocation()) {} 982 983 /// Sets the location of '('. 984 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 985 986 /// Returns the location of '('. 987 SourceLocation getLParenLoc() const { return LParenLoc; } 988 989 /// Returns kind of the clause. 990 llvm::omp::ProcBindKind getProcBindKind() const { return Kind; } 991 992 /// Returns location of clause kind. 993 SourceLocation getProcBindKindKwLoc() const { return KindKwLoc; } 994 995 child_range children() { 996 return child_range(child_iterator(), child_iterator()); 997 } 998 999 const_child_range children() const { 1000 return const_child_range(const_child_iterator(), const_child_iterator()); 1001 } 1002 1003 child_range used_children() { 1004 return child_range(child_iterator(), child_iterator()); 1005 } 1006 const_child_range used_children() const { 1007 return const_child_range(const_child_iterator(), const_child_iterator()); 1008 } 1009 1010 static bool classof(const OMPClause *T) { 1011 return T->getClauseKind() == OMPC_proc_bind; 1012 } 1013}; 1014 1015/// This represents 'unified_address' clause in the '#pragma omp requires' 1016/// directive. 1017/// 1018/// \code 1019/// #pragma omp requires unified_address 1020/// \endcode 1021/// In this example directive '#pragma omp requires' has 'unified_address' 1022/// clause. 1023class OMPUnifiedAddressClause final : public OMPClause { 1024public: 1025 friend class OMPClauseReader; 1026 /// Build 'unified_address' clause. 1027 /// 1028 /// \param StartLoc Starting location of the clause. 1029 /// \param EndLoc Ending location of the clause. 1030 OMPUnifiedAddressClause(SourceLocation StartLoc, SourceLocation EndLoc) 1031 : OMPClause(OMPC_unified_address, StartLoc, EndLoc) {} 1032 1033 /// Build an empty clause. 1034 OMPUnifiedAddressClause() 1035 : OMPClause(OMPC_unified_address, SourceLocation(), SourceLocation()) {} 1036 1037 child_range children() { 1038 return child_range(child_iterator(), child_iterator()); 1039 } 1040 1041 const_child_range children() const { 1042 return const_child_range(const_child_iterator(), const_child_iterator()); 1043 } 1044 1045 child_range used_children() { 1046 return child_range(child_iterator(), child_iterator()); 1047 } 1048 const_child_range used_children() const { 1049 return const_child_range(const_child_iterator(), const_child_iterator()); 1050 } 1051 1052 static bool classof(const OMPClause *T) { 1053 return T->getClauseKind() == OMPC_unified_address; 1054 } 1055}; 1056 1057/// This represents 'unified_shared_memory' clause in the '#pragma omp requires' 1058/// directive. 1059/// 1060/// \code 1061/// #pragma omp requires unified_shared_memory 1062/// \endcode 1063/// In this example directive '#pragma omp requires' has 'unified_shared_memory' 1064/// clause. 1065class OMPUnifiedSharedMemoryClause final : public OMPClause { 1066public: 1067 friend class OMPClauseReader; 1068 /// Build 'unified_shared_memory' clause. 1069 /// 1070 /// \param StartLoc Starting location of the clause. 1071 /// \param EndLoc Ending location of the clause. 1072 OMPUnifiedSharedMemoryClause(SourceLocation StartLoc, SourceLocation EndLoc) 1073 : OMPClause(OMPC_unified_shared_memory, StartLoc, EndLoc) {} 1074 1075 /// Build an empty clause. 1076 OMPUnifiedSharedMemoryClause() 1077 : OMPClause(OMPC_unified_shared_memory, SourceLocation(), SourceLocation()) {} 1078 1079 child_range children() { 1080 return child_range(child_iterator(), child_iterator()); 1081 } 1082 1083 const_child_range children() const { 1084 return const_child_range(const_child_iterator(), const_child_iterator()); 1085 } 1086 1087 child_range used_children() { 1088 return child_range(child_iterator(), child_iterator()); 1089 } 1090 const_child_range used_children() const { 1091 return const_child_range(const_child_iterator(), const_child_iterator()); 1092 } 1093 1094 static bool classof(const OMPClause *T) { 1095 return T->getClauseKind() == OMPC_unified_shared_memory; 1096 } 1097}; 1098 1099/// This represents 'reverse_offload' clause in the '#pragma omp requires' 1100/// directive. 1101/// 1102/// \code 1103/// #pragma omp requires reverse_offload 1104/// \endcode 1105/// In this example directive '#pragma omp requires' has 'reverse_offload' 1106/// clause. 1107class OMPReverseOffloadClause final : public OMPClause { 1108public: 1109 friend class OMPClauseReader; 1110 /// Build 'reverse_offload' clause. 1111 /// 1112 /// \param StartLoc Starting location of the clause. 1113 /// \param EndLoc Ending location of the clause. 1114 OMPReverseOffloadClause(SourceLocation StartLoc, SourceLocation EndLoc) 1115 : OMPClause(OMPC_reverse_offload, StartLoc, EndLoc) {} 1116 1117 /// Build an empty clause. 1118 OMPReverseOffloadClause() 1119 : OMPClause(OMPC_reverse_offload, SourceLocation(), SourceLocation()) {} 1120 1121 child_range children() { 1122 return child_range(child_iterator(), child_iterator()); 1123 } 1124 1125 const_child_range children() const { 1126 return const_child_range(const_child_iterator(), const_child_iterator()); 1127 } 1128 1129 child_range used_children() { 1130 return child_range(child_iterator(), child_iterator()); 1131 } 1132 const_child_range used_children() const { 1133 return const_child_range(const_child_iterator(), const_child_iterator()); 1134 } 1135 1136 static bool classof(const OMPClause *T) { 1137 return T->getClauseKind() == OMPC_reverse_offload; 1138 } 1139}; 1140 1141/// This represents 'dynamic_allocators' clause in the '#pragma omp requires' 1142/// directive. 1143/// 1144/// \code 1145/// #pragma omp requires dynamic_allocators 1146/// \endcode 1147/// In this example directive '#pragma omp requires' has 'dynamic_allocators' 1148/// clause. 1149class OMPDynamicAllocatorsClause final : public OMPClause { 1150public: 1151 friend class OMPClauseReader; 1152 /// Build 'dynamic_allocators' clause. 1153 /// 1154 /// \param StartLoc Starting location of the clause. 1155 /// \param EndLoc Ending location of the clause. 1156 OMPDynamicAllocatorsClause(SourceLocation StartLoc, SourceLocation EndLoc) 1157 : OMPClause(OMPC_dynamic_allocators, StartLoc, EndLoc) {} 1158 1159 /// Build an empty clause. 1160 OMPDynamicAllocatorsClause() 1161 : OMPClause(OMPC_dynamic_allocators, SourceLocation(), SourceLocation()) { 1162 } 1163 1164 child_range children() { 1165 return child_range(child_iterator(), child_iterator()); 1166 } 1167 1168 const_child_range children() const { 1169 return const_child_range(const_child_iterator(), const_child_iterator()); 1170 } 1171 1172 child_range used_children() { 1173 return child_range(child_iterator(), child_iterator()); 1174 } 1175 const_child_range used_children() const { 1176 return const_child_range(const_child_iterator(), const_child_iterator()); 1177 } 1178 1179 static bool classof(const OMPClause *T) { 1180 return T->getClauseKind() == OMPC_dynamic_allocators; 1181 } 1182}; 1183 1184/// This represents 'atomic_default_mem_order' clause in the '#pragma omp 1185/// requires' directive. 1186/// 1187/// \code 1188/// #pragma omp requires atomic_default_mem_order(seq_cst) 1189/// \endcode 1190/// In this example directive '#pragma omp requires' has simple 1191/// atomic_default_mem_order' clause with kind 'seq_cst'. 1192class OMPAtomicDefaultMemOrderClause final : public OMPClause { 1193 friend class OMPClauseReader; 1194 1195 /// Location of '(' 1196 SourceLocation LParenLoc; 1197 1198 /// A kind of the 'atomic_default_mem_order' clause. 1199 OpenMPAtomicDefaultMemOrderClauseKind Kind = 1200 OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown; 1201 1202 /// Start location of the kind in source code. 1203 SourceLocation KindKwLoc; 1204 1205 /// Set kind of the clause. 1206 /// 1207 /// \param K Kind of clause. 1208 void setAtomicDefaultMemOrderKind(OpenMPAtomicDefaultMemOrderClauseKind K) { 1209 Kind = K; 1210 } 1211 1212 /// Set clause kind location. 1213 /// 1214 /// \param KLoc Kind location. 1215 void setAtomicDefaultMemOrderKindKwLoc(SourceLocation KLoc) { 1216 KindKwLoc = KLoc; 1217 } 1218 1219public: 1220 /// Build 'atomic_default_mem_order' clause with argument \a A ('seq_cst', 1221 /// 'acq_rel' or 'relaxed'). 1222 /// 1223 /// \param A Argument of the clause ('seq_cst', 'acq_rel' or 'relaxed'). 1224 /// \param ALoc Starting location of the argument. 1225 /// \param StartLoc Starting location of the clause. 1226 /// \param LParenLoc Location of '('. 1227 /// \param EndLoc Ending location of the clause. 1228 OMPAtomicDefaultMemOrderClause(OpenMPAtomicDefaultMemOrderClauseKind A, 1229 SourceLocation ALoc, SourceLocation StartLoc, 1230 SourceLocation LParenLoc, 1231 SourceLocation EndLoc) 1232 : OMPClause(OMPC_atomic_default_mem_order, StartLoc, EndLoc), 1233 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {} 1234 1235 /// Build an empty clause. 1236 OMPAtomicDefaultMemOrderClause() 1237 : OMPClause(OMPC_atomic_default_mem_order, SourceLocation(), 1238 SourceLocation()) {} 1239 1240 /// Sets the location of '('. 1241 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 1242 1243 /// Returns the locaiton of '('. 1244 SourceLocation getLParenLoc() const { return LParenLoc; } 1245 1246 /// Returns kind of the clause. 1247 OpenMPAtomicDefaultMemOrderClauseKind getAtomicDefaultMemOrderKind() const { 1248 return Kind; 1249 } 1250 1251 /// Returns location of clause kind. 1252 SourceLocation getAtomicDefaultMemOrderKindKwLoc() const { return KindKwLoc; } 1253 1254 child_range children() { 1255 return child_range(child_iterator(), child_iterator()); 1256 } 1257 1258 const_child_range children() const { 1259 return const_child_range(const_child_iterator(), const_child_iterator()); 1260 } 1261 1262 child_range used_children() { 1263 return child_range(child_iterator(), child_iterator()); 1264 } 1265 const_child_range used_children() const { 1266 return const_child_range(const_child_iterator(), const_child_iterator()); 1267 } 1268 1269 static bool classof(const OMPClause *T) { 1270 return T->getClauseKind() == OMPC_atomic_default_mem_order; 1271 } 1272}; 1273 1274/// This represents 'schedule' clause in the '#pragma omp ...' directive. 1275/// 1276/// \code 1277/// #pragma omp for schedule(static, 3) 1278/// \endcode 1279/// In this example directive '#pragma omp for' has 'schedule' clause with 1280/// arguments 'static' and '3'. 1281class OMPScheduleClause : public OMPClause, public OMPClauseWithPreInit { 1282 friend class OMPClauseReader; 1283 1284 /// Location of '('. 1285 SourceLocation LParenLoc; 1286 1287 /// A kind of the 'schedule' clause. 1288 OpenMPScheduleClauseKind Kind = OMPC_SCHEDULE_unknown; 1289 1290 /// Modifiers for 'schedule' clause. 1291 enum {FIRST, SECOND, NUM_MODIFIERS}; 1292 OpenMPScheduleClauseModifier Modifiers[NUM_MODIFIERS]; 1293 1294 /// Locations of modifiers. 1295 SourceLocation ModifiersLoc[NUM_MODIFIERS]; 1296 1297 /// Start location of the schedule ind in source code. 1298 SourceLocation KindLoc; 1299 1300 /// Location of ',' (if any). 1301 SourceLocation CommaLoc; 1302 1303 /// Chunk size. 1304 Expr *ChunkSize = nullptr; 1305 1306 /// Set schedule kind. 1307 /// 1308 /// \param K Schedule kind. 1309 void setScheduleKind(OpenMPScheduleClauseKind K) { Kind = K; } 1310 1311 /// Set the first schedule modifier. 1312 /// 1313 /// \param M Schedule modifier. 1314 void setFirstScheduleModifier(OpenMPScheduleClauseModifier M) { 1315 Modifiers[FIRST] = M; 1316 } 1317 1318 /// Set the second schedule modifier. 1319 /// 1320 /// \param M Schedule modifier. 1321 void setSecondScheduleModifier(OpenMPScheduleClauseModifier M) { 1322 Modifiers[SECOND] = M; 1323 } 1324 1325 /// Set location of the first schedule modifier. 1326 void setFirstScheduleModifierLoc(SourceLocation Loc) { 1327 ModifiersLoc[FIRST] = Loc; 1328 } 1329 1330 /// Set location of the second schedule modifier. 1331 void setSecondScheduleModifierLoc(SourceLocation Loc) { 1332 ModifiersLoc[SECOND] = Loc; 1333 } 1334 1335 /// Set schedule modifier location. 1336 /// 1337 /// \param M Schedule modifier location. 1338 void setScheduleModifer(OpenMPScheduleClauseModifier M) { 1339 if (Modifiers[FIRST] == OMPC_SCHEDULE_MODIFIER_unknown) 1340 Modifiers[FIRST] = M; 1341 else { 1342 assert(Modifiers[SECOND] == OMPC_SCHEDULE_MODIFIER_unknown); 1343 Modifiers[SECOND] = M; 1344 } 1345 } 1346 1347 /// Sets the location of '('. 1348 /// 1349 /// \param Loc Location of '('. 1350 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 1351 1352 /// Set schedule kind start location. 1353 /// 1354 /// \param KLoc Schedule kind location. 1355 void setScheduleKindLoc(SourceLocation KLoc) { KindLoc = KLoc; } 1356 1357 /// Set location of ','. 1358 /// 1359 /// \param Loc Location of ','. 1360 void setCommaLoc(SourceLocation Loc) { CommaLoc = Loc; } 1361 1362 /// Set chunk size. 1363 /// 1364 /// \param E Chunk size. 1365 void setChunkSize(Expr *E) { ChunkSize = E; } 1366 1367public: 1368 /// Build 'schedule' clause with schedule kind \a Kind and chunk size 1369 /// expression \a ChunkSize. 1370 /// 1371 /// \param StartLoc Starting location of the clause. 1372 /// \param LParenLoc Location of '('. 1373 /// \param KLoc Starting location of the argument. 1374 /// \param CommaLoc Location of ','. 1375 /// \param EndLoc Ending location of the clause. 1376 /// \param Kind Schedule kind. 1377 /// \param ChunkSize Chunk size. 1378 /// \param HelperChunkSize Helper chunk size for combined directives. 1379 /// \param M1 The first modifier applied to 'schedule' clause. 1380 /// \param M1Loc Location of the first modifier 1381 /// \param M2 The second modifier applied to 'schedule' clause. 1382 /// \param M2Loc Location of the second modifier 1383 OMPScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc, 1384 SourceLocation KLoc, SourceLocation CommaLoc, 1385 SourceLocation EndLoc, OpenMPScheduleClauseKind Kind, 1386 Expr *ChunkSize, Stmt *HelperChunkSize, 1387 OpenMPScheduleClauseModifier M1, SourceLocation M1Loc, 1388 OpenMPScheduleClauseModifier M2, SourceLocation M2Loc) 1389 : OMPClause(OMPC_schedule, StartLoc, EndLoc), OMPClauseWithPreInit(this), 1390 LParenLoc(LParenLoc), Kind(Kind), KindLoc(KLoc), CommaLoc(CommaLoc), 1391 ChunkSize(ChunkSize) { 1392 setPreInitStmt(HelperChunkSize); 1393 Modifiers[FIRST] = M1; 1394 Modifiers[SECOND] = M2; 1395 ModifiersLoc[FIRST] = M1Loc; 1396 ModifiersLoc[SECOND] = M2Loc; 1397 } 1398 1399 /// Build an empty clause. 1400 explicit OMPScheduleClause() 1401 : OMPClause(OMPC_schedule, SourceLocation(), SourceLocation()), 1402 OMPClauseWithPreInit(this) { 1403 Modifiers[FIRST] = OMPC_SCHEDULE_MODIFIER_unknown; 1404 Modifiers[SECOND] = OMPC_SCHEDULE_MODIFIER_unknown; 1405 } 1406 1407 /// Get kind of the clause. 1408 OpenMPScheduleClauseKind getScheduleKind() const { return Kind; } 1409 1410 /// Get the first modifier of the clause. 1411 OpenMPScheduleClauseModifier getFirstScheduleModifier() const { 1412 return Modifiers[FIRST]; 1413 } 1414 1415 /// Get the second modifier of the clause. 1416 OpenMPScheduleClauseModifier getSecondScheduleModifier() const { 1417 return Modifiers[SECOND]; 1418 } 1419 1420 /// Get location of '('. 1421 SourceLocation getLParenLoc() { return LParenLoc; } 1422 1423 /// Get kind location. 1424 SourceLocation getScheduleKindLoc() { return KindLoc; } 1425 1426 /// Get the first modifier location. 1427 SourceLocation getFirstScheduleModifierLoc() const { 1428 return ModifiersLoc[FIRST]; 1429 } 1430 1431 /// Get the second modifier location. 1432 SourceLocation getSecondScheduleModifierLoc() const { 1433 return ModifiersLoc[SECOND]; 1434 } 1435 1436 /// Get location of ','. 1437 SourceLocation getCommaLoc() { return CommaLoc; } 1438 1439 /// Get chunk size. 1440 Expr *getChunkSize() { return ChunkSize; } 1441 1442 /// Get chunk size. 1443 const Expr *getChunkSize() const { return ChunkSize; } 1444 1445 child_range children() { 1446 return child_range(reinterpret_cast<Stmt **>(&ChunkSize), 1447 reinterpret_cast<Stmt **>(&ChunkSize) + 1); 1448 } 1449 1450 const_child_range children() const { 1451 auto Children = const_cast<OMPScheduleClause *>(this)->children(); 1452 return const_child_range(Children.begin(), Children.end()); 1453 } 1454 1455 child_range used_children() { 1456 return child_range(child_iterator(), child_iterator()); 1457 } 1458 const_child_range used_children() const { 1459 return const_child_range(const_child_iterator(), const_child_iterator()); 1460 } 1461 1462 static bool classof(const OMPClause *T) { 1463 return T->getClauseKind() == OMPC_schedule; 1464 } 1465}; 1466 1467/// This represents 'ordered' clause in the '#pragma omp ...' directive. 1468/// 1469/// \code 1470/// #pragma omp for ordered (2) 1471/// \endcode 1472/// In this example directive '#pragma omp for' has 'ordered' clause with 1473/// parameter 2. 1474class OMPOrderedClause final 1475 : public OMPClause, 1476 private llvm::TrailingObjects<OMPOrderedClause, Expr *> { 1477 friend class OMPClauseReader; 1478 friend TrailingObjects; 1479 1480 /// Location of '('. 1481 SourceLocation LParenLoc; 1482 1483 /// Number of for-loops. 1484 Stmt *NumForLoops = nullptr; 1485 1486 /// Real number of loops. 1487 unsigned NumberOfLoops = 0; 1488 1489 /// Build 'ordered' clause. 1490 /// 1491 /// \param Num Expression, possibly associated with this clause. 1492 /// \param NumLoops Number of loops, associated with this clause. 1493 /// \param StartLoc Starting location of the clause. 1494 /// \param LParenLoc Location of '('. 1495 /// \param EndLoc Ending location of the clause. 1496 OMPOrderedClause(Expr *Num, unsigned NumLoops, SourceLocation StartLoc, 1497 SourceLocation LParenLoc, SourceLocation EndLoc) 1498 : OMPClause(OMPC_ordered, StartLoc, EndLoc), LParenLoc(LParenLoc), 1499 NumForLoops(Num), NumberOfLoops(NumLoops) {} 1500 1501 /// Build an empty clause. 1502 explicit OMPOrderedClause(unsigned NumLoops) 1503 : OMPClause(OMPC_ordered, SourceLocation(), SourceLocation()), 1504 NumberOfLoops(NumLoops) {} 1505 1506 /// Set the number of associated for-loops. 1507 void setNumForLoops(Expr *Num) { NumForLoops = Num; } 1508 1509public: 1510 /// Build 'ordered' clause. 1511 /// 1512 /// \param Num Expression, possibly associated with this clause. 1513 /// \param NumLoops Number of loops, associated with this clause. 1514 /// \param StartLoc Starting location of the clause. 1515 /// \param LParenLoc Location of '('. 1516 /// \param EndLoc Ending location of the clause. 1517 static OMPOrderedClause *Create(const ASTContext &C, Expr *Num, 1518 unsigned NumLoops, SourceLocation StartLoc, 1519 SourceLocation LParenLoc, 1520 SourceLocation EndLoc); 1521 1522 /// Build an empty clause. 1523 static OMPOrderedClause* CreateEmpty(const ASTContext &C, unsigned NumLoops); 1524 1525 /// Sets the location of '('. 1526 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 1527 1528 /// Returns the location of '('. 1529 SourceLocation getLParenLoc() const { return LParenLoc; } 1530 1531 /// Return the number of associated for-loops. 1532 Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); } 1533 1534 /// Set number of iterations for the specified loop. 1535 void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations); 1536 /// Get number of iterations for all the loops. 1537 ArrayRef<Expr *> getLoopNumIterations() const; 1538 1539 /// Set loop counter for the specified loop. 1540 void setLoopCounter(unsigned NumLoop, Expr *Counter); 1541 /// Get loops counter for the specified loop. 1542 Expr *getLoopCounter(unsigned NumLoop); 1543 const Expr *getLoopCounter(unsigned NumLoop) const; 1544 1545 child_range children() { return child_range(&NumForLoops, &NumForLoops + 1); } 1546 1547 const_child_range children() const { 1548 return const_child_range(&NumForLoops, &NumForLoops + 1); 1549 } 1550 1551 child_range used_children() { 1552 return child_range(child_iterator(), child_iterator()); 1553 } 1554 const_child_range used_children() const { 1555 return const_child_range(const_child_iterator(), const_child_iterator()); 1556 } 1557 1558 static bool classof(const OMPClause *T) { 1559 return T->getClauseKind() == OMPC_ordered; 1560 } 1561}; 1562 1563/// This represents 'nowait' clause in the '#pragma omp ...' directive. 1564/// 1565/// \code 1566/// #pragma omp for nowait 1567/// \endcode 1568/// In this example directive '#pragma omp for' has 'nowait' clause. 1569class OMPNowaitClause : public OMPClause { 1570public: 1571 /// Build 'nowait' clause. 1572 /// 1573 /// \param StartLoc Starting location of the clause. 1574 /// \param EndLoc Ending location of the clause. 1575 OMPNowaitClause(SourceLocation StartLoc, SourceLocation EndLoc) 1576 : OMPClause(OMPC_nowait, StartLoc, EndLoc) {} 1577 1578 /// Build an empty clause. 1579 OMPNowaitClause() 1580 : OMPClause(OMPC_nowait, SourceLocation(), SourceLocation()) {} 1581 1582 child_range children() { 1583 return child_range(child_iterator(), child_iterator()); 1584 } 1585 1586 const_child_range children() const { 1587 return const_child_range(const_child_iterator(), const_child_iterator()); 1588 } 1589 1590 child_range used_children() { 1591 return child_range(child_iterator(), child_iterator()); 1592 } 1593 const_child_range used_children() const { 1594 return const_child_range(const_child_iterator(), const_child_iterator()); 1595 } 1596 1597 static bool classof(const OMPClause *T) { 1598 return T->getClauseKind() == OMPC_nowait; 1599 } 1600}; 1601 1602/// This represents 'untied' clause in the '#pragma omp ...' directive. 1603/// 1604/// \code 1605/// #pragma omp task untied 1606/// \endcode 1607/// In this example directive '#pragma omp task' has 'untied' clause. 1608class OMPUntiedClause : public OMPClause { 1609public: 1610 /// Build 'untied' clause. 1611 /// 1612 /// \param StartLoc Starting location of the clause. 1613 /// \param EndLoc Ending location of the clause. 1614 OMPUntiedClause(SourceLocation StartLoc, SourceLocation EndLoc) 1615 : OMPClause(OMPC_untied, StartLoc, EndLoc) {} 1616 1617 /// Build an empty clause. 1618 OMPUntiedClause() 1619 : OMPClause(OMPC_untied, SourceLocation(), SourceLocation()) {} 1620 1621 child_range children() { 1622 return child_range(child_iterator(), child_iterator()); 1623 } 1624 1625 const_child_range children() const { 1626 return const_child_range(const_child_iterator(), const_child_iterator()); 1627 } 1628 1629 child_range used_children() { 1630 return child_range(child_iterator(), child_iterator()); 1631 } 1632 const_child_range used_children() const { 1633 return const_child_range(const_child_iterator(), const_child_iterator()); 1634 } 1635 1636 static bool classof(const OMPClause *T) { 1637 return T->getClauseKind() == OMPC_untied; 1638 } 1639}; 1640 1641/// This represents 'mergeable' clause in the '#pragma omp ...' 1642/// directive. 1643/// 1644/// \code 1645/// #pragma omp task mergeable 1646/// \endcode 1647/// In this example directive '#pragma omp task' has 'mergeable' clause. 1648class OMPMergeableClause : public OMPClause { 1649public: 1650 /// Build 'mergeable' clause. 1651 /// 1652 /// \param StartLoc Starting location of the clause. 1653 /// \param EndLoc Ending location of the clause. 1654 OMPMergeableClause(SourceLocation StartLoc, SourceLocation EndLoc) 1655 : OMPClause(OMPC_mergeable, StartLoc, EndLoc) {} 1656 1657 /// Build an empty clause. 1658 OMPMergeableClause() 1659 : OMPClause(OMPC_mergeable, SourceLocation(), SourceLocation()) {} 1660 1661 child_range children() { 1662 return child_range(child_iterator(), child_iterator()); 1663 } 1664 1665 const_child_range children() const { 1666 return const_child_range(const_child_iterator(), const_child_iterator()); 1667 } 1668 1669 child_range used_children() { 1670 return child_range(child_iterator(), child_iterator()); 1671 } 1672 const_child_range used_children() const { 1673 return const_child_range(const_child_iterator(), const_child_iterator()); 1674 } 1675 1676 static bool classof(const OMPClause *T) { 1677 return T->getClauseKind() == OMPC_mergeable; 1678 } 1679}; 1680 1681/// This represents 'read' clause in the '#pragma omp atomic' directive. 1682/// 1683/// \code 1684/// #pragma omp atomic read 1685/// \endcode 1686/// In this example directive '#pragma omp atomic' has 'read' clause. 1687class OMPReadClause : public OMPClause { 1688public: 1689 /// Build 'read' clause. 1690 /// 1691 /// \param StartLoc Starting location of the clause. 1692 /// \param EndLoc Ending location of the clause. 1693 OMPReadClause(SourceLocation StartLoc, SourceLocation EndLoc) 1694 : OMPClause(OMPC_read, StartLoc, EndLoc) {} 1695 1696 /// Build an empty clause. 1697 OMPReadClause() : OMPClause(OMPC_read, SourceLocation(), SourceLocation()) {} 1698 1699 child_range children() { 1700 return child_range(child_iterator(), child_iterator()); 1701 } 1702 1703 const_child_range children() const { 1704 return const_child_range(const_child_iterator(), const_child_iterator()); 1705 } 1706 1707 child_range used_children() { 1708 return child_range(child_iterator(), child_iterator()); 1709 } 1710 const_child_range used_children() const { 1711 return const_child_range(const_child_iterator(), const_child_iterator()); 1712 } 1713 1714 static bool classof(const OMPClause *T) { 1715 return T->getClauseKind() == OMPC_read; 1716 } 1717}; 1718 1719/// This represents 'write' clause in the '#pragma omp atomic' directive. 1720/// 1721/// \code 1722/// #pragma omp atomic write 1723/// \endcode 1724/// In this example directive '#pragma omp atomic' has 'write' clause. 1725class OMPWriteClause : public OMPClause { 1726public: 1727 /// Build 'write' clause. 1728 /// 1729 /// \param StartLoc Starting location of the clause. 1730 /// \param EndLoc Ending location of the clause. 1731 OMPWriteClause(SourceLocation StartLoc, SourceLocation EndLoc) 1732 : OMPClause(OMPC_write, StartLoc, EndLoc) {} 1733 1734 /// Build an empty clause. 1735 OMPWriteClause() 1736 : OMPClause(OMPC_write, SourceLocation(), SourceLocation()) {} 1737 1738 child_range children() { 1739 return child_range(child_iterator(), child_iterator()); 1740 } 1741 1742 const_child_range children() const { 1743 return const_child_range(const_child_iterator(), const_child_iterator()); 1744 } 1745 1746 child_range used_children() { 1747 return child_range(child_iterator(), child_iterator()); 1748 } 1749 const_child_range used_children() const { 1750 return const_child_range(const_child_iterator(), const_child_iterator()); 1751 } 1752 1753 static bool classof(const OMPClause *T) { 1754 return T->getClauseKind() == OMPC_write; 1755 } 1756}; 1757 1758/// This represents 'update' clause in the '#pragma omp atomic' 1759/// directive. 1760/// 1761/// \code 1762/// #pragma omp atomic update 1763/// \endcode 1764/// In this example directive '#pragma omp atomic' has 'update' clause. 1765class OMPUpdateClause : public OMPClause { 1766public: 1767 /// Build 'update' clause. 1768 /// 1769 /// \param StartLoc Starting location of the clause. 1770 /// \param EndLoc Ending location of the clause. 1771 OMPUpdateClause(SourceLocation StartLoc, SourceLocation EndLoc) 1772 : OMPClause(OMPC_update, StartLoc, EndLoc) {} 1773 1774 /// Build an empty clause. 1775 OMPUpdateClause() 1776 : OMPClause(OMPC_update, SourceLocation(), SourceLocation()) {} 1777 1778 child_range children() { 1779 return child_range(child_iterator(), child_iterator()); 1780 } 1781 1782 const_child_range children() const { 1783 return const_child_range(const_child_iterator(), const_child_iterator()); 1784 } 1785 1786 child_range used_children() { 1787 return child_range(child_iterator(), child_iterator()); 1788 } 1789 const_child_range used_children() const { 1790 return const_child_range(const_child_iterator(), const_child_iterator()); 1791 } 1792 1793 static bool classof(const OMPClause *T) { 1794 return T->getClauseKind() == OMPC_update; 1795 } 1796}; 1797 1798/// This represents 'capture' clause in the '#pragma omp atomic' 1799/// directive. 1800/// 1801/// \code 1802/// #pragma omp atomic capture 1803/// \endcode 1804/// In this example directive '#pragma omp atomic' has 'capture' clause. 1805class OMPCaptureClause : public OMPClause { 1806public: 1807 /// Build 'capture' clause. 1808 /// 1809 /// \param StartLoc Starting location of the clause. 1810 /// \param EndLoc Ending location of the clause. 1811 OMPCaptureClause(SourceLocation StartLoc, SourceLocation EndLoc) 1812 : OMPClause(OMPC_capture, StartLoc, EndLoc) {} 1813 1814 /// Build an empty clause. 1815 OMPCaptureClause() 1816 : OMPClause(OMPC_capture, SourceLocation(), SourceLocation()) {} 1817 1818 child_range children() { 1819 return child_range(child_iterator(), child_iterator()); 1820 } 1821 1822 const_child_range children() const { 1823 return const_child_range(const_child_iterator(), const_child_iterator()); 1824 } 1825 1826 child_range used_children() { 1827 return child_range(child_iterator(), child_iterator()); 1828 } 1829 const_child_range used_children() const { 1830 return const_child_range(const_child_iterator(), const_child_iterator()); 1831 } 1832 1833 static bool classof(const OMPClause *T) { 1834 return T->getClauseKind() == OMPC_capture; 1835 } 1836}; 1837 1838/// This represents 'seq_cst' clause in the '#pragma omp atomic' 1839/// directive. 1840/// 1841/// \code 1842/// #pragma omp atomic seq_cst 1843/// \endcode 1844/// In this example directive '#pragma omp atomic' has 'seq_cst' clause. 1845class OMPSeqCstClause : public OMPClause { 1846public: 1847 /// Build 'seq_cst' clause. 1848 /// 1849 /// \param StartLoc Starting location of the clause. 1850 /// \param EndLoc Ending location of the clause. 1851 OMPSeqCstClause(SourceLocation StartLoc, SourceLocation EndLoc) 1852 : OMPClause(OMPC_seq_cst, StartLoc, EndLoc) {} 1853 1854 /// Build an empty clause. 1855 OMPSeqCstClause() 1856 : OMPClause(OMPC_seq_cst, SourceLocation(), SourceLocation()) {} 1857 1858 child_range children() { 1859 return child_range(child_iterator(), child_iterator()); 1860 } 1861 1862 const_child_range children() const { 1863 return const_child_range(const_child_iterator(), const_child_iterator()); 1864 } 1865 1866 child_range used_children() { 1867 return child_range(child_iterator(), child_iterator()); 1868 } 1869 const_child_range used_children() const { 1870 return const_child_range(const_child_iterator(), const_child_iterator()); 1871 } 1872 1873 static bool classof(const OMPClause *T) { 1874 return T->getClauseKind() == OMPC_seq_cst; 1875 } 1876}; 1877 1878/// This represents clause 'private' in the '#pragma omp ...' directives. 1879/// 1880/// \code 1881/// #pragma omp parallel private(a,b) 1882/// \endcode 1883/// In this example directive '#pragma omp parallel' has clause 'private' 1884/// with the variables 'a' and 'b'. 1885class OMPPrivateClause final 1886 : public OMPVarListClause<OMPPrivateClause>, 1887 private llvm::TrailingObjects<OMPPrivateClause, Expr *> { 1888 friend class OMPClauseReader; 1889 friend OMPVarListClause; 1890 friend TrailingObjects; 1891 1892 /// Build clause with number of variables \a N. 1893 /// 1894 /// \param StartLoc Starting location of the clause. 1895 /// \param LParenLoc Location of '('. 1896 /// \param EndLoc Ending location of the clause. 1897 /// \param N Number of the variables in the clause. 1898 OMPPrivateClause(SourceLocation StartLoc, SourceLocation LParenLoc, 1899 SourceLocation EndLoc, unsigned N) 1900 : OMPVarListClause<OMPPrivateClause>(OMPC_private, StartLoc, LParenLoc, 1901 EndLoc, N) {} 1902 1903 /// Build an empty clause. 1904 /// 1905 /// \param N Number of variables. 1906 explicit OMPPrivateClause(unsigned N) 1907 : OMPVarListClause<OMPPrivateClause>(OMPC_private, SourceLocation(), 1908 SourceLocation(), SourceLocation(), 1909 N) {} 1910 1911 /// Sets the list of references to private copies with initializers for 1912 /// new private variables. 1913 /// \param VL List of references. 1914 void setPrivateCopies(ArrayRef<Expr *> VL); 1915 1916 /// Gets the list of references to private copies with initializers for 1917 /// new private variables. 1918 MutableArrayRef<Expr *> getPrivateCopies() { 1919 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 1920 } 1921 ArrayRef<const Expr *> getPrivateCopies() const { 1922 return llvm::makeArrayRef(varlist_end(), varlist_size()); 1923 } 1924 1925public: 1926 /// Creates clause with a list of variables \a VL. 1927 /// 1928 /// \param C AST context. 1929 /// \param StartLoc Starting location of the clause. 1930 /// \param LParenLoc Location of '('. 1931 /// \param EndLoc Ending location of the clause. 1932 /// \param VL List of references to the variables. 1933 /// \param PrivateVL List of references to private copies with initializers. 1934 static OMPPrivateClause *Create(const ASTContext &C, SourceLocation StartLoc, 1935 SourceLocation LParenLoc, 1936 SourceLocation EndLoc, ArrayRef<Expr *> VL, 1937 ArrayRef<Expr *> PrivateVL); 1938 1939 /// Creates an empty clause with the place for \a N variables. 1940 /// 1941 /// \param C AST context. 1942 /// \param N The number of variables. 1943 static OMPPrivateClause *CreateEmpty(const ASTContext &C, unsigned N); 1944 1945 using private_copies_iterator = MutableArrayRef<Expr *>::iterator; 1946 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator; 1947 using private_copies_range = llvm::iterator_range<private_copies_iterator>; 1948 using private_copies_const_range = 1949 llvm::iterator_range<private_copies_const_iterator>; 1950 1951 private_copies_range private_copies() { 1952 return private_copies_range(getPrivateCopies().begin(), 1953 getPrivateCopies().end()); 1954 } 1955 1956 private_copies_const_range private_copies() const { 1957 return private_copies_const_range(getPrivateCopies().begin(), 1958 getPrivateCopies().end()); 1959 } 1960 1961 child_range children() { 1962 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 1963 reinterpret_cast<Stmt **>(varlist_end())); 1964 } 1965 1966 const_child_range children() const { 1967 auto Children = const_cast<OMPPrivateClause *>(this)->children(); 1968 return const_child_range(Children.begin(), Children.end()); 1969 } 1970 1971 child_range used_children() { 1972 return child_range(child_iterator(), child_iterator()); 1973 } 1974 const_child_range used_children() const { 1975 return const_child_range(const_child_iterator(), const_child_iterator()); 1976 } 1977 1978 static bool classof(const OMPClause *T) { 1979 return T->getClauseKind() == OMPC_private; 1980 } 1981}; 1982 1983/// This represents clause 'firstprivate' in the '#pragma omp ...' 1984/// directives. 1985/// 1986/// \code 1987/// #pragma omp parallel firstprivate(a,b) 1988/// \endcode 1989/// In this example directive '#pragma omp parallel' has clause 'firstprivate' 1990/// with the variables 'a' and 'b'. 1991class OMPFirstprivateClause final 1992 : public OMPVarListClause<OMPFirstprivateClause>, 1993 public OMPClauseWithPreInit, 1994 private llvm::TrailingObjects<OMPFirstprivateClause, Expr *> { 1995 friend class OMPClauseReader; 1996 friend OMPVarListClause; 1997 friend TrailingObjects; 1998 1999 /// Build clause with number of variables \a N. 2000 /// 2001 /// \param StartLoc Starting location of the clause. 2002 /// \param LParenLoc Location of '('. 2003 /// \param EndLoc Ending location of the clause. 2004 /// \param N Number of the variables in the clause. 2005 OMPFirstprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2006 SourceLocation EndLoc, unsigned N) 2007 : OMPVarListClause<OMPFirstprivateClause>(OMPC_firstprivate, StartLoc, 2008 LParenLoc, EndLoc, N), 2009 OMPClauseWithPreInit(this) {} 2010 2011 /// Build an empty clause. 2012 /// 2013 /// \param N Number of variables. 2014 explicit OMPFirstprivateClause(unsigned N) 2015 : OMPVarListClause<OMPFirstprivateClause>( 2016 OMPC_firstprivate, SourceLocation(), SourceLocation(), 2017 SourceLocation(), N), 2018 OMPClauseWithPreInit(this) {} 2019 2020 /// Sets the list of references to private copies with initializers for 2021 /// new private variables. 2022 /// \param VL List of references. 2023 void setPrivateCopies(ArrayRef<Expr *> VL); 2024 2025 /// Gets the list of references to private copies with initializers for 2026 /// new private variables. 2027 MutableArrayRef<Expr *> getPrivateCopies() { 2028 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 2029 } 2030 ArrayRef<const Expr *> getPrivateCopies() const { 2031 return llvm::makeArrayRef(varlist_end(), varlist_size()); 2032 } 2033 2034 /// Sets the list of references to initializer variables for new 2035 /// private variables. 2036 /// \param VL List of references. 2037 void setInits(ArrayRef<Expr *> VL); 2038 2039 /// Gets the list of references to initializer variables for new 2040 /// private variables. 2041 MutableArrayRef<Expr *> getInits() { 2042 return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); 2043 } 2044 ArrayRef<const Expr *> getInits() const { 2045 return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); 2046 } 2047 2048public: 2049 /// Creates clause with a list of variables \a VL. 2050 /// 2051 /// \param C AST context. 2052 /// \param StartLoc Starting location of the clause. 2053 /// \param LParenLoc Location of '('. 2054 /// \param EndLoc Ending location of the clause. 2055 /// \param VL List of references to the original variables. 2056 /// \param PrivateVL List of references to private copies with initializers. 2057 /// \param InitVL List of references to auto generated variables used for 2058 /// initialization of a single array element. Used if firstprivate variable is 2059 /// of array type. 2060 /// \param PreInit Statement that must be executed before entering the OpenMP 2061 /// region with this clause. 2062 static OMPFirstprivateClause * 2063 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 2064 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL, 2065 ArrayRef<Expr *> InitVL, Stmt *PreInit); 2066 2067 /// Creates an empty clause with the place for \a N variables. 2068 /// 2069 /// \param C AST context. 2070 /// \param N The number of variables. 2071 static OMPFirstprivateClause *CreateEmpty(const ASTContext &C, unsigned N); 2072 2073 using private_copies_iterator = MutableArrayRef<Expr *>::iterator; 2074 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator; 2075 using private_copies_range = llvm::iterator_range<private_copies_iterator>; 2076 using private_copies_const_range = 2077 llvm::iterator_range<private_copies_const_iterator>; 2078 2079 private_copies_range private_copies() { 2080 return private_copies_range(getPrivateCopies().begin(), 2081 getPrivateCopies().end()); 2082 } 2083 private_copies_const_range private_copies() const { 2084 return private_copies_const_range(getPrivateCopies().begin(), 2085 getPrivateCopies().end()); 2086 } 2087 2088 using inits_iterator = MutableArrayRef<Expr *>::iterator; 2089 using inits_const_iterator = ArrayRef<const Expr *>::iterator; 2090 using inits_range = llvm::iterator_range<inits_iterator>; 2091 using inits_const_range = llvm::iterator_range<inits_const_iterator>; 2092 2093 inits_range inits() { 2094 return inits_range(getInits().begin(), getInits().end()); 2095 } 2096 inits_const_range inits() const { 2097 return inits_const_range(getInits().begin(), getInits().end()); 2098 } 2099 2100 child_range children() { 2101 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2102 reinterpret_cast<Stmt **>(varlist_end())); 2103 } 2104 2105 const_child_range children() const { 2106 auto Children = const_cast<OMPFirstprivateClause *>(this)->children(); 2107 return const_child_range(Children.begin(), Children.end()); 2108 } 2109 2110 child_range used_children() { 2111 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2112 reinterpret_cast<Stmt **>(varlist_end())); 2113 } 2114 const_child_range used_children() const { 2115 auto Children = const_cast<OMPFirstprivateClause *>(this)->used_children(); 2116 return const_child_range(Children.begin(), Children.end()); 2117 } 2118 2119 static bool classof(const OMPClause *T) { 2120 return T->getClauseKind() == OMPC_firstprivate; 2121 } 2122}; 2123 2124/// This represents clause 'lastprivate' in the '#pragma omp ...' 2125/// directives. 2126/// 2127/// \code 2128/// #pragma omp simd lastprivate(a,b) 2129/// \endcode 2130/// In this example directive '#pragma omp simd' has clause 'lastprivate' 2131/// with the variables 'a' and 'b'. 2132class OMPLastprivateClause final 2133 : public OMPVarListClause<OMPLastprivateClause>, 2134 public OMPClauseWithPostUpdate, 2135 private llvm::TrailingObjects<OMPLastprivateClause, Expr *> { 2136 // There are 4 additional tail-allocated arrays at the end of the class: 2137 // 1. Contains list of pseudo variables with the default initialization for 2138 // each non-firstprivate variables. Used in codegen for initialization of 2139 // lastprivate copies. 2140 // 2. List of helper expressions for proper generation of assignment operation 2141 // required for lastprivate clause. This list represents private variables 2142 // (for arrays, single array element). 2143 // 3. List of helper expressions for proper generation of assignment operation 2144 // required for lastprivate clause. This list represents original variables 2145 // (for arrays, single array element). 2146 // 4. List of helper expressions that represents assignment operation: 2147 // \code 2148 // DstExprs = SrcExprs; 2149 // \endcode 2150 // Required for proper codegen of final assignment performed by the 2151 // lastprivate clause. 2152 friend class OMPClauseReader; 2153 friend OMPVarListClause; 2154 friend TrailingObjects; 2155 2156 /// Optional lastprivate kind, e.g. 'conditional', if specified by user. 2157 OpenMPLastprivateModifier LPKind; 2158 /// Optional location of the lasptrivate kind, if specified by user. 2159 SourceLocation LPKindLoc; 2160 /// Optional colon location, if specified by user. 2161 SourceLocation ColonLoc; 2162 2163 /// Build clause with number of variables \a N. 2164 /// 2165 /// \param StartLoc Starting location of the clause. 2166 /// \param LParenLoc Location of '('. 2167 /// \param EndLoc Ending location of the clause. 2168 /// \param N Number of the variables in the clause. 2169 OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2170 SourceLocation EndLoc, OpenMPLastprivateModifier LPKind, 2171 SourceLocation LPKindLoc, SourceLocation ColonLoc, 2172 unsigned N) 2173 : OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc, 2174 LParenLoc, EndLoc, N), 2175 OMPClauseWithPostUpdate(this), LPKind(LPKind), LPKindLoc(LPKindLoc), 2176 ColonLoc(ColonLoc) {} 2177 2178 /// Build an empty clause. 2179 /// 2180 /// \param N Number of variables. 2181 explicit OMPLastprivateClause(unsigned N) 2182 : OMPVarListClause<OMPLastprivateClause>( 2183 OMPC_lastprivate, SourceLocation(), SourceLocation(), 2184 SourceLocation(), N), 2185 OMPClauseWithPostUpdate(this) {} 2186 2187 /// Get the list of helper expressions for initialization of private 2188 /// copies for lastprivate variables. 2189 MutableArrayRef<Expr *> getPrivateCopies() { 2190 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 2191 } 2192 ArrayRef<const Expr *> getPrivateCopies() const { 2193 return llvm::makeArrayRef(varlist_end(), varlist_size()); 2194 } 2195 2196 /// Set list of helper expressions, required for proper codegen of the 2197 /// clause. These expressions represent private variables (for arrays, single 2198 /// array element) in the final assignment statement performed by the 2199 /// lastprivate clause. 2200 void setSourceExprs(ArrayRef<Expr *> SrcExprs); 2201 2202 /// Get the list of helper source expressions. 2203 MutableArrayRef<Expr *> getSourceExprs() { 2204 return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); 2205 } 2206 ArrayRef<const Expr *> getSourceExprs() const { 2207 return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); 2208 } 2209 2210 /// Set list of helper expressions, required for proper codegen of the 2211 /// clause. These expressions represent original variables (for arrays, single 2212 /// array element) in the final assignment statement performed by the 2213 /// lastprivate clause. 2214 void setDestinationExprs(ArrayRef<Expr *> DstExprs); 2215 2216 /// Get the list of helper destination expressions. 2217 MutableArrayRef<Expr *> getDestinationExprs() { 2218 return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); 2219 } 2220 ArrayRef<const Expr *> getDestinationExprs() const { 2221 return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); 2222 } 2223 2224 /// Set list of helper assignment expressions, required for proper 2225 /// codegen of the clause. These expressions are assignment expressions that 2226 /// assign private copy of the variable to original variable. 2227 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps); 2228 2229 /// Get the list of helper assignment expressions. 2230 MutableArrayRef<Expr *> getAssignmentOps() { 2231 return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); 2232 } 2233 ArrayRef<const Expr *> getAssignmentOps() const { 2234 return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); 2235 } 2236 2237 /// Sets lastprivate kind. 2238 void setKind(OpenMPLastprivateModifier Kind) { LPKind = Kind; } 2239 /// Sets location of the lastprivate kind. 2240 void setKindLoc(SourceLocation Loc) { LPKindLoc = Loc; } 2241 /// Sets colon symbol location. 2242 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 2243 2244public: 2245 /// Creates clause with a list of variables \a VL. 2246 /// 2247 /// \param C AST context. 2248 /// \param StartLoc Starting location of the clause. 2249 /// \param LParenLoc Location of '('. 2250 /// \param EndLoc Ending location of the clause. 2251 /// \param VL List of references to the variables. 2252 /// \param SrcExprs List of helper expressions for proper generation of 2253 /// assignment operation required for lastprivate clause. This list represents 2254 /// private variables (for arrays, single array element). 2255 /// \param DstExprs List of helper expressions for proper generation of 2256 /// assignment operation required for lastprivate clause. This list represents 2257 /// original variables (for arrays, single array element). 2258 /// \param AssignmentOps List of helper expressions that represents assignment 2259 /// operation: 2260 /// \code 2261 /// DstExprs = SrcExprs; 2262 /// \endcode 2263 /// Required for proper codegen of final assignment performed by the 2264 /// lastprivate clause. 2265 /// \param LPKind Lastprivate kind, e.g. 'conditional'. 2266 /// \param LPKindLoc Location of the lastprivate kind. 2267 /// \param ColonLoc Location of the ':' symbol if lastprivate kind is used. 2268 /// \param PreInit Statement that must be executed before entering the OpenMP 2269 /// region with this clause. 2270 /// \param PostUpdate Expression that must be executed after exit from the 2271 /// OpenMP region with this clause. 2272 static OMPLastprivateClause * 2273 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 2274 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 2275 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, 2276 OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc, 2277 SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate); 2278 2279 /// Creates an empty clause with the place for \a N variables. 2280 /// 2281 /// \param C AST context. 2282 /// \param N The number of variables. 2283 static OMPLastprivateClause *CreateEmpty(const ASTContext &C, unsigned N); 2284 2285 /// Lastprivate kind. 2286 OpenMPLastprivateModifier getKind() const { return LPKind; } 2287 /// Returns the location of the lastprivate kind. 2288 SourceLocation getKindLoc() const { return LPKindLoc; } 2289 /// Returns the location of the ':' symbol, if any. 2290 SourceLocation getColonLoc() const { return ColonLoc; } 2291 2292 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 2293 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 2294 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 2295 using helper_expr_const_range = 2296 llvm::iterator_range<helper_expr_const_iterator>; 2297 2298 /// Set list of helper expressions, required for generation of private 2299 /// copies of original lastprivate variables. 2300 void setPrivateCopies(ArrayRef<Expr *> PrivateCopies); 2301 2302 helper_expr_const_range private_copies() const { 2303 return helper_expr_const_range(getPrivateCopies().begin(), 2304 getPrivateCopies().end()); 2305 } 2306 2307 helper_expr_range private_copies() { 2308 return helper_expr_range(getPrivateCopies().begin(), 2309 getPrivateCopies().end()); 2310 } 2311 2312 helper_expr_const_range source_exprs() const { 2313 return helper_expr_const_range(getSourceExprs().begin(), 2314 getSourceExprs().end()); 2315 } 2316 2317 helper_expr_range source_exprs() { 2318 return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end()); 2319 } 2320 2321 helper_expr_const_range destination_exprs() const { 2322 return helper_expr_const_range(getDestinationExprs().begin(), 2323 getDestinationExprs().end()); 2324 } 2325 2326 helper_expr_range destination_exprs() { 2327 return helper_expr_range(getDestinationExprs().begin(), 2328 getDestinationExprs().end()); 2329 } 2330 2331 helper_expr_const_range assignment_ops() const { 2332 return helper_expr_const_range(getAssignmentOps().begin(), 2333 getAssignmentOps().end()); 2334 } 2335 2336 helper_expr_range assignment_ops() { 2337 return helper_expr_range(getAssignmentOps().begin(), 2338 getAssignmentOps().end()); 2339 } 2340 2341 child_range children() { 2342 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2343 reinterpret_cast<Stmt **>(varlist_end())); 2344 } 2345 2346 const_child_range children() const { 2347 auto Children = const_cast<OMPLastprivateClause *>(this)->children(); 2348 return const_child_range(Children.begin(), Children.end()); 2349 } 2350 2351 child_range used_children() { 2352 return child_range(child_iterator(), child_iterator()); 2353 } 2354 const_child_range used_children() const { 2355 return const_child_range(const_child_iterator(), const_child_iterator()); 2356 } 2357 2358 static bool classof(const OMPClause *T) { 2359 return T->getClauseKind() == OMPC_lastprivate; 2360 } 2361}; 2362 2363/// This represents clause 'shared' in the '#pragma omp ...' directives. 2364/// 2365/// \code 2366/// #pragma omp parallel shared(a,b) 2367/// \endcode 2368/// In this example directive '#pragma omp parallel' has clause 'shared' 2369/// with the variables 'a' and 'b'. 2370class OMPSharedClause final 2371 : public OMPVarListClause<OMPSharedClause>, 2372 private llvm::TrailingObjects<OMPSharedClause, Expr *> { 2373 friend OMPVarListClause; 2374 friend TrailingObjects; 2375 2376 /// Build clause with number of variables \a N. 2377 /// 2378 /// \param StartLoc Starting location of the clause. 2379 /// \param LParenLoc Location of '('. 2380 /// \param EndLoc Ending location of the clause. 2381 /// \param N Number of the variables in the clause. 2382 OMPSharedClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2383 SourceLocation EndLoc, unsigned N) 2384 : OMPVarListClause<OMPSharedClause>(OMPC_shared, StartLoc, LParenLoc, 2385 EndLoc, N) {} 2386 2387 /// Build an empty clause. 2388 /// 2389 /// \param N Number of variables. 2390 explicit OMPSharedClause(unsigned N) 2391 : OMPVarListClause<OMPSharedClause>(OMPC_shared, SourceLocation(), 2392 SourceLocation(), SourceLocation(), 2393 N) {} 2394 2395public: 2396 /// Creates clause with a list of variables \a VL. 2397 /// 2398 /// \param C AST context. 2399 /// \param StartLoc Starting location of the clause. 2400 /// \param LParenLoc Location of '('. 2401 /// \param EndLoc Ending location of the clause. 2402 /// \param VL List of references to the variables. 2403 static OMPSharedClause *Create(const ASTContext &C, SourceLocation StartLoc, 2404 SourceLocation LParenLoc, 2405 SourceLocation EndLoc, ArrayRef<Expr *> VL); 2406 2407 /// Creates an empty clause with \a N variables. 2408 /// 2409 /// \param C AST context. 2410 /// \param N The number of variables. 2411 static OMPSharedClause *CreateEmpty(const ASTContext &C, unsigned N); 2412 2413 child_range children() { 2414 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2415 reinterpret_cast<Stmt **>(varlist_end())); 2416 } 2417 2418 const_child_range children() const { 2419 auto Children = const_cast<OMPSharedClause *>(this)->children(); 2420 return const_child_range(Children.begin(), Children.end()); 2421 } 2422 2423 child_range used_children() { 2424 return child_range(child_iterator(), child_iterator()); 2425 } 2426 const_child_range used_children() const { 2427 return const_child_range(const_child_iterator(), const_child_iterator()); 2428 } 2429 2430 static bool classof(const OMPClause *T) { 2431 return T->getClauseKind() == OMPC_shared; 2432 } 2433}; 2434 2435/// This represents clause 'reduction' in the '#pragma omp ...' 2436/// directives. 2437/// 2438/// \code 2439/// #pragma omp parallel reduction(+:a,b) 2440/// \endcode 2441/// In this example directive '#pragma omp parallel' has clause 'reduction' 2442/// with operator '+' and the variables 'a' and 'b'. 2443class OMPReductionClause final 2444 : public OMPVarListClause<OMPReductionClause>, 2445 public OMPClauseWithPostUpdate, 2446 private llvm::TrailingObjects<OMPReductionClause, Expr *> { 2447 friend class OMPClauseReader; 2448 friend OMPVarListClause; 2449 friend TrailingObjects; 2450 2451 /// Location of ':'. 2452 SourceLocation ColonLoc; 2453 2454 /// Nested name specifier for C++. 2455 NestedNameSpecifierLoc QualifierLoc; 2456 2457 /// Name of custom operator. 2458 DeclarationNameInfo NameInfo; 2459 2460 /// Build clause with number of variables \a N. 2461 /// 2462 /// \param StartLoc Starting location of the clause. 2463 /// \param LParenLoc Location of '('. 2464 /// \param EndLoc Ending location of the clause. 2465 /// \param ColonLoc Location of ':'. 2466 /// \param N Number of the variables in the clause. 2467 /// \param QualifierLoc The nested-name qualifier with location information 2468 /// \param NameInfo The full name info for reduction identifier. 2469 OMPReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2470 SourceLocation ColonLoc, SourceLocation EndLoc, unsigned N, 2471 NestedNameSpecifierLoc QualifierLoc, 2472 const DeclarationNameInfo &NameInfo) 2473 : OMPVarListClause<OMPReductionClause>(OMPC_reduction, StartLoc, 2474 LParenLoc, EndLoc, N), 2475 OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc), 2476 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {} 2477 2478 /// Build an empty clause. 2479 /// 2480 /// \param N Number of variables. 2481 explicit OMPReductionClause(unsigned N) 2482 : OMPVarListClause<OMPReductionClause>(OMPC_reduction, SourceLocation(), 2483 SourceLocation(), SourceLocation(), 2484 N), 2485 OMPClauseWithPostUpdate(this) {} 2486 2487 /// Sets location of ':' symbol in clause. 2488 void setColonLoc(SourceLocation CL) { ColonLoc = CL; } 2489 2490 /// Sets the name info for specified reduction identifier. 2491 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; } 2492 2493 /// Sets the nested name specifier. 2494 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; } 2495 2496 /// Set list of helper expressions, required for proper codegen of the 2497 /// clause. These expressions represent private copy of the reduction 2498 /// variable. 2499 void setPrivates(ArrayRef<Expr *> Privates); 2500 2501 /// Get the list of helper privates. 2502 MutableArrayRef<Expr *> getPrivates() { 2503 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 2504 } 2505 ArrayRef<const Expr *> getPrivates() const { 2506 return llvm::makeArrayRef(varlist_end(), varlist_size()); 2507 } 2508 2509 /// Set list of helper expressions, required for proper codegen of the 2510 /// clause. These expressions represent LHS expression in the final 2511 /// reduction expression performed by the reduction clause. 2512 void setLHSExprs(ArrayRef<Expr *> LHSExprs); 2513 2514 /// Get the list of helper LHS expressions. 2515 MutableArrayRef<Expr *> getLHSExprs() { 2516 return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); 2517 } 2518 ArrayRef<const Expr *> getLHSExprs() const { 2519 return llvm::makeArrayRef(getPrivates().end(), varlist_size()); 2520 } 2521 2522 /// Set list of helper expressions, required for proper codegen of the 2523 /// clause. These expressions represent RHS expression in the final 2524 /// reduction expression performed by the reduction clause. 2525 /// Also, variables in these expressions are used for proper initialization of 2526 /// reduction copies. 2527 void setRHSExprs(ArrayRef<Expr *> RHSExprs); 2528 2529 /// Get the list of helper destination expressions. 2530 MutableArrayRef<Expr *> getRHSExprs() { 2531 return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); 2532 } 2533 ArrayRef<const Expr *> getRHSExprs() const { 2534 return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); 2535 } 2536 2537 /// Set list of helper reduction expressions, required for proper 2538 /// codegen of the clause. These expressions are binary expressions or 2539 /// operator/custom reduction call that calculates new value from source 2540 /// helper expressions to destination helper expressions. 2541 void setReductionOps(ArrayRef<Expr *> ReductionOps); 2542 2543 /// Get the list of helper reduction expressions. 2544 MutableArrayRef<Expr *> getReductionOps() { 2545 return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); 2546 } 2547 ArrayRef<const Expr *> getReductionOps() const { 2548 return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); 2549 } 2550 2551public: 2552 /// Creates clause with a list of variables \a VL. 2553 /// 2554 /// \param StartLoc Starting location of the clause. 2555 /// \param LParenLoc Location of '('. 2556 /// \param ColonLoc Location of ':'. 2557 /// \param EndLoc Ending location of the clause. 2558 /// \param VL The variables in the clause. 2559 /// \param QualifierLoc The nested-name qualifier with location information 2560 /// \param NameInfo The full name info for reduction identifier. 2561 /// \param Privates List of helper expressions for proper generation of 2562 /// private copies. 2563 /// \param LHSExprs List of helper expressions for proper generation of 2564 /// assignment operation required for copyprivate clause. This list represents 2565 /// LHSs of the reduction expressions. 2566 /// \param RHSExprs List of helper expressions for proper generation of 2567 /// assignment operation required for copyprivate clause. This list represents 2568 /// RHSs of the reduction expressions. 2569 /// Also, variables in these expressions are used for proper initialization of 2570 /// reduction copies. 2571 /// \param ReductionOps List of helper expressions that represents reduction 2572 /// expressions: 2573 /// \code 2574 /// LHSExprs binop RHSExprs; 2575 /// operator binop(LHSExpr, RHSExpr); 2576 /// <CutomReduction>(LHSExpr, RHSExpr); 2577 /// \endcode 2578 /// Required for proper codegen of final reduction operation performed by the 2579 /// reduction clause. 2580 /// \param PreInit Statement that must be executed before entering the OpenMP 2581 /// region with this clause. 2582 /// \param PostUpdate Expression that must be executed after exit from the 2583 /// OpenMP region with this clause. 2584 static OMPReductionClause * 2585 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 2586 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 2587 NestedNameSpecifierLoc QualifierLoc, 2588 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates, 2589 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs, 2590 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate); 2591 2592 /// Creates an empty clause with the place for \a N variables. 2593 /// 2594 /// \param C AST context. 2595 /// \param N The number of variables. 2596 static OMPReductionClause *CreateEmpty(const ASTContext &C, unsigned N); 2597 2598 /// Gets location of ':' symbol in clause. 2599 SourceLocation getColonLoc() const { return ColonLoc; } 2600 2601 /// Gets the name info for specified reduction identifier. 2602 const DeclarationNameInfo &getNameInfo() const { return NameInfo; } 2603 2604 /// Gets the nested name specifier. 2605 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 2606 2607 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 2608 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 2609 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 2610 using helper_expr_const_range = 2611 llvm::iterator_range<helper_expr_const_iterator>; 2612 2613 helper_expr_const_range privates() const { 2614 return helper_expr_const_range(getPrivates().begin(), getPrivates().end()); 2615 } 2616 2617 helper_expr_range privates() { 2618 return helper_expr_range(getPrivates().begin(), getPrivates().end()); 2619 } 2620 2621 helper_expr_const_range lhs_exprs() const { 2622 return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end()); 2623 } 2624 2625 helper_expr_range lhs_exprs() { 2626 return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end()); 2627 } 2628 2629 helper_expr_const_range rhs_exprs() const { 2630 return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end()); 2631 } 2632 2633 helper_expr_range rhs_exprs() { 2634 return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end()); 2635 } 2636 2637 helper_expr_const_range reduction_ops() const { 2638 return helper_expr_const_range(getReductionOps().begin(), 2639 getReductionOps().end()); 2640 } 2641 2642 helper_expr_range reduction_ops() { 2643 return helper_expr_range(getReductionOps().begin(), 2644 getReductionOps().end()); 2645 } 2646 2647 child_range children() { 2648 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2649 reinterpret_cast<Stmt **>(varlist_end())); 2650 } 2651 2652 const_child_range children() const { 2653 auto Children = const_cast<OMPReductionClause *>(this)->children(); 2654 return const_child_range(Children.begin(), Children.end()); 2655 } 2656 2657 child_range used_children() { 2658 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2659 reinterpret_cast<Stmt **>(varlist_end())); 2660 } 2661 const_child_range used_children() const { 2662 auto Children = const_cast<OMPReductionClause *>(this)->used_children(); 2663 return const_child_range(Children.begin(), Children.end()); 2664 } 2665 2666 static bool classof(const OMPClause *T) { 2667 return T->getClauseKind() == OMPC_reduction; 2668 } 2669}; 2670 2671/// This represents clause 'task_reduction' in the '#pragma omp taskgroup' 2672/// directives. 2673/// 2674/// \code 2675/// #pragma omp taskgroup task_reduction(+:a,b) 2676/// \endcode 2677/// In this example directive '#pragma omp taskgroup' has clause 2678/// 'task_reduction' with operator '+' and the variables 'a' and 'b'. 2679class OMPTaskReductionClause final 2680 : public OMPVarListClause<OMPTaskReductionClause>, 2681 public OMPClauseWithPostUpdate, 2682 private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> { 2683 friend class OMPClauseReader; 2684 friend OMPVarListClause; 2685 friend TrailingObjects; 2686 2687 /// Location of ':'. 2688 SourceLocation ColonLoc; 2689 2690 /// Nested name specifier for C++. 2691 NestedNameSpecifierLoc QualifierLoc; 2692 2693 /// Name of custom operator. 2694 DeclarationNameInfo NameInfo; 2695 2696 /// Build clause with number of variables \a N. 2697 /// 2698 /// \param StartLoc Starting location of the clause. 2699 /// \param LParenLoc Location of '('. 2700 /// \param EndLoc Ending location of the clause. 2701 /// \param ColonLoc Location of ':'. 2702 /// \param N Number of the variables in the clause. 2703 /// \param QualifierLoc The nested-name qualifier with location information 2704 /// \param NameInfo The full name info for reduction identifier. 2705 OMPTaskReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2706 SourceLocation ColonLoc, SourceLocation EndLoc, 2707 unsigned N, NestedNameSpecifierLoc QualifierLoc, 2708 const DeclarationNameInfo &NameInfo) 2709 : OMPVarListClause<OMPTaskReductionClause>(OMPC_task_reduction, StartLoc, 2710 LParenLoc, EndLoc, N), 2711 OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc), 2712 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {} 2713 2714 /// Build an empty clause. 2715 /// 2716 /// \param N Number of variables. 2717 explicit OMPTaskReductionClause(unsigned N) 2718 : OMPVarListClause<OMPTaskReductionClause>( 2719 OMPC_task_reduction, SourceLocation(), SourceLocation(), 2720 SourceLocation(), N), 2721 OMPClauseWithPostUpdate(this) {} 2722 2723 /// Sets location of ':' symbol in clause. 2724 void setColonLoc(SourceLocation CL) { ColonLoc = CL; } 2725 2726 /// Sets the name info for specified reduction identifier. 2727 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; } 2728 2729 /// Sets the nested name specifier. 2730 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; } 2731 2732 /// Set list of helper expressions, required for proper codegen of the clause. 2733 /// These expressions represent private copy of the reduction variable. 2734 void setPrivates(ArrayRef<Expr *> Privates); 2735 2736 /// Get the list of helper privates. 2737 MutableArrayRef<Expr *> getPrivates() { 2738 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 2739 } 2740 ArrayRef<const Expr *> getPrivates() const { 2741 return llvm::makeArrayRef(varlist_end(), varlist_size()); 2742 } 2743 2744 /// Set list of helper expressions, required for proper codegen of the clause. 2745 /// These expressions represent LHS expression in the final reduction 2746 /// expression performed by the reduction clause. 2747 void setLHSExprs(ArrayRef<Expr *> LHSExprs); 2748 2749 /// Get the list of helper LHS expressions. 2750 MutableArrayRef<Expr *> getLHSExprs() { 2751 return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); 2752 } 2753 ArrayRef<const Expr *> getLHSExprs() const { 2754 return llvm::makeArrayRef(getPrivates().end(), varlist_size()); 2755 } 2756 2757 /// Set list of helper expressions, required for proper codegen of the clause. 2758 /// These expressions represent RHS expression in the final reduction 2759 /// expression performed by the reduction clause. Also, variables in these 2760 /// expressions are used for proper initialization of reduction copies. 2761 void setRHSExprs(ArrayRef<Expr *> RHSExprs); 2762 2763 /// Get the list of helper destination expressions. 2764 MutableArrayRef<Expr *> getRHSExprs() { 2765 return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); 2766 } 2767 ArrayRef<const Expr *> getRHSExprs() const { 2768 return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); 2769 } 2770 2771 /// Set list of helper reduction expressions, required for proper 2772 /// codegen of the clause. These expressions are binary expressions or 2773 /// operator/custom reduction call that calculates new value from source 2774 /// helper expressions to destination helper expressions. 2775 void setReductionOps(ArrayRef<Expr *> ReductionOps); 2776 2777 /// Get the list of helper reduction expressions. 2778 MutableArrayRef<Expr *> getReductionOps() { 2779 return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); 2780 } 2781 ArrayRef<const Expr *> getReductionOps() const { 2782 return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); 2783 } 2784 2785public: 2786 /// Creates clause with a list of variables \a VL. 2787 /// 2788 /// \param StartLoc Starting location of the clause. 2789 /// \param LParenLoc Location of '('. 2790 /// \param ColonLoc Location of ':'. 2791 /// \param EndLoc Ending location of the clause. 2792 /// \param VL The variables in the clause. 2793 /// \param QualifierLoc The nested-name qualifier with location information 2794 /// \param NameInfo The full name info for reduction identifier. 2795 /// \param Privates List of helper expressions for proper generation of 2796 /// private copies. 2797 /// \param LHSExprs List of helper expressions for proper generation of 2798 /// assignment operation required for copyprivate clause. This list represents 2799 /// LHSs of the reduction expressions. 2800 /// \param RHSExprs List of helper expressions for proper generation of 2801 /// assignment operation required for copyprivate clause. This list represents 2802 /// RHSs of the reduction expressions. 2803 /// Also, variables in these expressions are used for proper initialization of 2804 /// reduction copies. 2805 /// \param ReductionOps List of helper expressions that represents reduction 2806 /// expressions: 2807 /// \code 2808 /// LHSExprs binop RHSExprs; 2809 /// operator binop(LHSExpr, RHSExpr); 2810 /// <CutomReduction>(LHSExpr, RHSExpr); 2811 /// \endcode 2812 /// Required for proper codegen of final reduction operation performed by the 2813 /// reduction clause. 2814 /// \param PreInit Statement that must be executed before entering the OpenMP 2815 /// region with this clause. 2816 /// \param PostUpdate Expression that must be executed after exit from the 2817 /// OpenMP region with this clause. 2818 static OMPTaskReductionClause * 2819 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 2820 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 2821 NestedNameSpecifierLoc QualifierLoc, 2822 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates, 2823 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs, 2824 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate); 2825 2826 /// Creates an empty clause with the place for \a N variables. 2827 /// 2828 /// \param C AST context. 2829 /// \param N The number of variables. 2830 static OMPTaskReductionClause *CreateEmpty(const ASTContext &C, unsigned N); 2831 2832 /// Gets location of ':' symbol in clause. 2833 SourceLocation getColonLoc() const { return ColonLoc; } 2834 2835 /// Gets the name info for specified reduction identifier. 2836 const DeclarationNameInfo &getNameInfo() const { return NameInfo; } 2837 2838 /// Gets the nested name specifier. 2839 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 2840 2841 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 2842 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 2843 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 2844 using helper_expr_const_range = 2845 llvm::iterator_range<helper_expr_const_iterator>; 2846 2847 helper_expr_const_range privates() const { 2848 return helper_expr_const_range(getPrivates().begin(), getPrivates().end()); 2849 } 2850 2851 helper_expr_range privates() { 2852 return helper_expr_range(getPrivates().begin(), getPrivates().end()); 2853 } 2854 2855 helper_expr_const_range lhs_exprs() const { 2856 return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end()); 2857 } 2858 2859 helper_expr_range lhs_exprs() { 2860 return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end()); 2861 } 2862 2863 helper_expr_const_range rhs_exprs() const { 2864 return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end()); 2865 } 2866 2867 helper_expr_range rhs_exprs() { 2868 return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end()); 2869 } 2870 2871 helper_expr_const_range reduction_ops() const { 2872 return helper_expr_const_range(getReductionOps().begin(), 2873 getReductionOps().end()); 2874 } 2875 2876 helper_expr_range reduction_ops() { 2877 return helper_expr_range(getReductionOps().begin(), 2878 getReductionOps().end()); 2879 } 2880 2881 child_range children() { 2882 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 2883 reinterpret_cast<Stmt **>(varlist_end())); 2884 } 2885 2886 const_child_range children() const { 2887 auto Children = const_cast<OMPTaskReductionClause *>(this)->children(); 2888 return const_child_range(Children.begin(), Children.end()); 2889 } 2890 2891 child_range used_children() { 2892 return child_range(child_iterator(), child_iterator()); 2893 } 2894 const_child_range used_children() const { 2895 return const_child_range(const_child_iterator(), const_child_iterator()); 2896 } 2897 2898 static bool classof(const OMPClause *T) { 2899 return T->getClauseKind() == OMPC_task_reduction; 2900 } 2901}; 2902 2903/// This represents clause 'in_reduction' in the '#pragma omp task' directives. 2904/// 2905/// \code 2906/// #pragma omp task in_reduction(+:a,b) 2907/// \endcode 2908/// In this example directive '#pragma omp task' has clause 'in_reduction' with 2909/// operator '+' and the variables 'a' and 'b'. 2910class OMPInReductionClause final 2911 : public OMPVarListClause<OMPInReductionClause>, 2912 public OMPClauseWithPostUpdate, 2913 private llvm::TrailingObjects<OMPInReductionClause, Expr *> { 2914 friend class OMPClauseReader; 2915 friend OMPVarListClause; 2916 friend TrailingObjects; 2917 2918 /// Location of ':'. 2919 SourceLocation ColonLoc; 2920 2921 /// Nested name specifier for C++. 2922 NestedNameSpecifierLoc QualifierLoc; 2923 2924 /// Name of custom operator. 2925 DeclarationNameInfo NameInfo; 2926 2927 /// Build clause with number of variables \a N. 2928 /// 2929 /// \param StartLoc Starting location of the clause. 2930 /// \param LParenLoc Location of '('. 2931 /// \param EndLoc Ending location of the clause. 2932 /// \param ColonLoc Location of ':'. 2933 /// \param N Number of the variables in the clause. 2934 /// \param QualifierLoc The nested-name qualifier with location information 2935 /// \param NameInfo The full name info for reduction identifier. 2936 OMPInReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc, 2937 SourceLocation ColonLoc, SourceLocation EndLoc, 2938 unsigned N, NestedNameSpecifierLoc QualifierLoc, 2939 const DeclarationNameInfo &NameInfo) 2940 : OMPVarListClause<OMPInReductionClause>(OMPC_in_reduction, StartLoc, 2941 LParenLoc, EndLoc, N), 2942 OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc), 2943 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {} 2944 2945 /// Build an empty clause. 2946 /// 2947 /// \param N Number of variables. 2948 explicit OMPInReductionClause(unsigned N) 2949 : OMPVarListClause<OMPInReductionClause>( 2950 OMPC_in_reduction, SourceLocation(), SourceLocation(), 2951 SourceLocation(), N), 2952 OMPClauseWithPostUpdate(this) {} 2953 2954 /// Sets location of ':' symbol in clause. 2955 void setColonLoc(SourceLocation CL) { ColonLoc = CL; } 2956 2957 /// Sets the name info for specified reduction identifier. 2958 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; } 2959 2960 /// Sets the nested name specifier. 2961 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; } 2962 2963 /// Set list of helper expressions, required for proper codegen of the clause. 2964 /// These expressions represent private copy of the reduction variable. 2965 void setPrivates(ArrayRef<Expr *> Privates); 2966 2967 /// Get the list of helper privates. 2968 MutableArrayRef<Expr *> getPrivates() { 2969 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 2970 } 2971 ArrayRef<const Expr *> getPrivates() const { 2972 return llvm::makeArrayRef(varlist_end(), varlist_size()); 2973 } 2974 2975 /// Set list of helper expressions, required for proper codegen of the clause. 2976 /// These expressions represent LHS expression in the final reduction 2977 /// expression performed by the reduction clause. 2978 void setLHSExprs(ArrayRef<Expr *> LHSExprs); 2979 2980 /// Get the list of helper LHS expressions. 2981 MutableArrayRef<Expr *> getLHSExprs() { 2982 return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); 2983 } 2984 ArrayRef<const Expr *> getLHSExprs() const { 2985 return llvm::makeArrayRef(getPrivates().end(), varlist_size()); 2986 } 2987 2988 /// Set list of helper expressions, required for proper codegen of the clause. 2989 /// These expressions represent RHS expression in the final reduction 2990 /// expression performed by the reduction clause. Also, variables in these 2991 /// expressions are used for proper initialization of reduction copies. 2992 void setRHSExprs(ArrayRef<Expr *> RHSExprs); 2993 2994 /// Get the list of helper destination expressions. 2995 MutableArrayRef<Expr *> getRHSExprs() { 2996 return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size()); 2997 } 2998 ArrayRef<const Expr *> getRHSExprs() const { 2999 return llvm::makeArrayRef(getLHSExprs().end(), varlist_size()); 3000 } 3001 3002 /// Set list of helper reduction expressions, required for proper 3003 /// codegen of the clause. These expressions are binary expressions or 3004 /// operator/custom reduction call that calculates new value from source 3005 /// helper expressions to destination helper expressions. 3006 void setReductionOps(ArrayRef<Expr *> ReductionOps); 3007 3008 /// Get the list of helper reduction expressions. 3009 MutableArrayRef<Expr *> getReductionOps() { 3010 return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size()); 3011 } 3012 ArrayRef<const Expr *> getReductionOps() const { 3013 return llvm::makeArrayRef(getRHSExprs().end(), varlist_size()); 3014 } 3015 3016 /// Set list of helper reduction taskgroup descriptors. 3017 void setTaskgroupDescriptors(ArrayRef<Expr *> ReductionOps); 3018 3019 /// Get the list of helper reduction taskgroup descriptors. 3020 MutableArrayRef<Expr *> getTaskgroupDescriptors() { 3021 return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size()); 3022 } 3023 ArrayRef<const Expr *> getTaskgroupDescriptors() const { 3024 return llvm::makeArrayRef(getReductionOps().end(), varlist_size()); 3025 } 3026 3027public: 3028 /// Creates clause with a list of variables \a VL. 3029 /// 3030 /// \param StartLoc Starting location of the clause. 3031 /// \param LParenLoc Location of '('. 3032 /// \param ColonLoc Location of ':'. 3033 /// \param EndLoc Ending location of the clause. 3034 /// \param VL The variables in the clause. 3035 /// \param QualifierLoc The nested-name qualifier with location information 3036 /// \param NameInfo The full name info for reduction identifier. 3037 /// \param Privates List of helper expressions for proper generation of 3038 /// private copies. 3039 /// \param LHSExprs List of helper expressions for proper generation of 3040 /// assignment operation required for copyprivate clause. This list represents 3041 /// LHSs of the reduction expressions. 3042 /// \param RHSExprs List of helper expressions for proper generation of 3043 /// assignment operation required for copyprivate clause. This list represents 3044 /// RHSs of the reduction expressions. 3045 /// Also, variables in these expressions are used for proper initialization of 3046 /// reduction copies. 3047 /// \param ReductionOps List of helper expressions that represents reduction 3048 /// expressions: 3049 /// \code 3050 /// LHSExprs binop RHSExprs; 3051 /// operator binop(LHSExpr, RHSExpr); 3052 /// <CutomReduction>(LHSExpr, RHSExpr); 3053 /// \endcode 3054 /// Required for proper codegen of final reduction operation performed by the 3055 /// reduction clause. 3056 /// \param TaskgroupDescriptors List of helper taskgroup descriptors for 3057 /// corresponding items in parent taskgroup task_reduction clause. 3058 /// \param PreInit Statement that must be executed before entering the OpenMP 3059 /// region with this clause. 3060 /// \param PostUpdate Expression that must be executed after exit from the 3061 /// OpenMP region with this clause. 3062 static OMPInReductionClause * 3063 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 3064 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 3065 NestedNameSpecifierLoc QualifierLoc, 3066 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates, 3067 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs, 3068 ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors, 3069 Stmt *PreInit, Expr *PostUpdate); 3070 3071 /// Creates an empty clause with the place for \a N variables. 3072 /// 3073 /// \param C AST context. 3074 /// \param N The number of variables. 3075 static OMPInReductionClause *CreateEmpty(const ASTContext &C, unsigned N); 3076 3077 /// Gets location of ':' symbol in clause. 3078 SourceLocation getColonLoc() const { return ColonLoc; } 3079 3080 /// Gets the name info for specified reduction identifier. 3081 const DeclarationNameInfo &getNameInfo() const { return NameInfo; } 3082 3083 /// Gets the nested name specifier. 3084 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 3085 3086 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 3087 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 3088 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 3089 using helper_expr_const_range = 3090 llvm::iterator_range<helper_expr_const_iterator>; 3091 3092 helper_expr_const_range privates() const { 3093 return helper_expr_const_range(getPrivates().begin(), getPrivates().end()); 3094 } 3095 3096 helper_expr_range privates() { 3097 return helper_expr_range(getPrivates().begin(), getPrivates().end()); 3098 } 3099 3100 helper_expr_const_range lhs_exprs() const { 3101 return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end()); 3102 } 3103 3104 helper_expr_range lhs_exprs() { 3105 return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end()); 3106 } 3107 3108 helper_expr_const_range rhs_exprs() const { 3109 return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end()); 3110 } 3111 3112 helper_expr_range rhs_exprs() { 3113 return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end()); 3114 } 3115 3116 helper_expr_const_range reduction_ops() const { 3117 return helper_expr_const_range(getReductionOps().begin(), 3118 getReductionOps().end()); 3119 } 3120 3121 helper_expr_range reduction_ops() { 3122 return helper_expr_range(getReductionOps().begin(), 3123 getReductionOps().end()); 3124 } 3125 3126 helper_expr_const_range taskgroup_descriptors() const { 3127 return helper_expr_const_range(getTaskgroupDescriptors().begin(), 3128 getTaskgroupDescriptors().end()); 3129 } 3130 3131 helper_expr_range taskgroup_descriptors() { 3132 return helper_expr_range(getTaskgroupDescriptors().begin(), 3133 getTaskgroupDescriptors().end()); 3134 } 3135 3136 child_range children() { 3137 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3138 reinterpret_cast<Stmt **>(varlist_end())); 3139 } 3140 3141 const_child_range children() const { 3142 auto Children = const_cast<OMPInReductionClause *>(this)->children(); 3143 return const_child_range(Children.begin(), Children.end()); 3144 } 3145 3146 child_range used_children() { 3147 return child_range(child_iterator(), child_iterator()); 3148 } 3149 const_child_range used_children() const { 3150 return const_child_range(const_child_iterator(), const_child_iterator()); 3151 } 3152 3153 static bool classof(const OMPClause *T) { 3154 return T->getClauseKind() == OMPC_in_reduction; 3155 } 3156}; 3157 3158/// This represents clause 'linear' in the '#pragma omp ...' 3159/// directives. 3160/// 3161/// \code 3162/// #pragma omp simd linear(a,b : 2) 3163/// \endcode 3164/// In this example directive '#pragma omp simd' has clause 'linear' 3165/// with variables 'a', 'b' and linear step '2'. 3166class OMPLinearClause final 3167 : public OMPVarListClause<OMPLinearClause>, 3168 public OMPClauseWithPostUpdate, 3169 private llvm::TrailingObjects<OMPLinearClause, Expr *> { 3170 friend class OMPClauseReader; 3171 friend OMPVarListClause; 3172 friend TrailingObjects; 3173 3174 /// Modifier of 'linear' clause. 3175 OpenMPLinearClauseKind Modifier = OMPC_LINEAR_val; 3176 3177 /// Location of linear modifier if any. 3178 SourceLocation ModifierLoc; 3179 3180 /// Location of ':'. 3181 SourceLocation ColonLoc; 3182 3183 /// Sets the linear step for clause. 3184 void setStep(Expr *Step) { *(getFinals().end()) = Step; } 3185 3186 /// Sets the expression to calculate linear step for clause. 3187 void setCalcStep(Expr *CalcStep) { *(getFinals().end() + 1) = CalcStep; } 3188 3189 /// Build 'linear' clause with given number of variables \a NumVars. 3190 /// 3191 /// \param StartLoc Starting location of the clause. 3192 /// \param LParenLoc Location of '('. 3193 /// \param ColonLoc Location of ':'. 3194 /// \param EndLoc Ending location of the clause. 3195 /// \param NumVars Number of variables. 3196 OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3197 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, 3198 SourceLocation ColonLoc, SourceLocation EndLoc, 3199 unsigned NumVars) 3200 : OMPVarListClause<OMPLinearClause>(OMPC_linear, StartLoc, LParenLoc, 3201 EndLoc, NumVars), 3202 OMPClauseWithPostUpdate(this), Modifier(Modifier), 3203 ModifierLoc(ModifierLoc), ColonLoc(ColonLoc) {} 3204 3205 /// Build an empty clause. 3206 /// 3207 /// \param NumVars Number of variables. 3208 explicit OMPLinearClause(unsigned NumVars) 3209 : OMPVarListClause<OMPLinearClause>(OMPC_linear, SourceLocation(), 3210 SourceLocation(), SourceLocation(), 3211 NumVars), 3212 OMPClauseWithPostUpdate(this) {} 3213 3214 /// Gets the list of initial values for linear variables. 3215 /// 3216 /// There are NumVars expressions with initial values allocated after the 3217 /// varlist, they are followed by NumVars update expressions (used to update 3218 /// the linear variable's value on current iteration) and they are followed by 3219 /// NumVars final expressions (used to calculate the linear variable's 3220 /// value after the loop body). After these lists, there are 2 helper 3221 /// expressions - linear step and a helper to calculate it before the 3222 /// loop body (used when the linear step is not constant): 3223 /// 3224 /// { Vars[] /* in OMPVarListClause */; Privates[]; Inits[]; Updates[]; 3225 /// Finals[]; Step; CalcStep; } 3226 MutableArrayRef<Expr *> getPrivates() { 3227 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 3228 } 3229 ArrayRef<const Expr *> getPrivates() const { 3230 return llvm::makeArrayRef(varlist_end(), varlist_size()); 3231 } 3232 3233 MutableArrayRef<Expr *> getInits() { 3234 return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size()); 3235 } 3236 ArrayRef<const Expr *> getInits() const { 3237 return llvm::makeArrayRef(getPrivates().end(), varlist_size()); 3238 } 3239 3240 /// Sets the list of update expressions for linear variables. 3241 MutableArrayRef<Expr *> getUpdates() { 3242 return MutableArrayRef<Expr *>(getInits().end(), varlist_size()); 3243 } 3244 ArrayRef<const Expr *> getUpdates() const { 3245 return llvm::makeArrayRef(getInits().end(), varlist_size()); 3246 } 3247 3248 /// Sets the list of final update expressions for linear variables. 3249 MutableArrayRef<Expr *> getFinals() { 3250 return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size()); 3251 } 3252 ArrayRef<const Expr *> getFinals() const { 3253 return llvm::makeArrayRef(getUpdates().end(), varlist_size()); 3254 } 3255 3256 /// Gets the list of used expressions for linear variables. 3257 MutableArrayRef<Expr *> getUsedExprs() { 3258 return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1); 3259 } 3260 ArrayRef<const Expr *> getUsedExprs() const { 3261 return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1); 3262 } 3263 3264 /// Sets the list of the copies of original linear variables. 3265 /// \param PL List of expressions. 3266 void setPrivates(ArrayRef<Expr *> PL); 3267 3268 /// Sets the list of the initial values for linear variables. 3269 /// \param IL List of expressions. 3270 void setInits(ArrayRef<Expr *> IL); 3271 3272public: 3273 /// Creates clause with a list of variables \a VL and a linear step 3274 /// \a Step. 3275 /// 3276 /// \param C AST Context. 3277 /// \param StartLoc Starting location of the clause. 3278 /// \param LParenLoc Location of '('. 3279 /// \param Modifier Modifier of 'linear' clause. 3280 /// \param ModifierLoc Modifier location. 3281 /// \param ColonLoc Location of ':'. 3282 /// \param EndLoc Ending location of the clause. 3283 /// \param VL List of references to the variables. 3284 /// \param PL List of private copies of original variables. 3285 /// \param IL List of initial values for the variables. 3286 /// \param Step Linear step. 3287 /// \param CalcStep Calculation of the linear step. 3288 /// \param PreInit Statement that must be executed before entering the OpenMP 3289 /// region with this clause. 3290 /// \param PostUpdate Expression that must be executed after exit from the 3291 /// OpenMP region with this clause. 3292 static OMPLinearClause * 3293 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 3294 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, 3295 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 3296 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep, 3297 Stmt *PreInit, Expr *PostUpdate); 3298 3299 /// Creates an empty clause with the place for \a NumVars variables. 3300 /// 3301 /// \param C AST context. 3302 /// \param NumVars Number of variables. 3303 static OMPLinearClause *CreateEmpty(const ASTContext &C, unsigned NumVars); 3304 3305 /// Set modifier. 3306 void setModifier(OpenMPLinearClauseKind Kind) { Modifier = Kind; } 3307 3308 /// Return modifier. 3309 OpenMPLinearClauseKind getModifier() const { return Modifier; } 3310 3311 /// Set modifier location. 3312 void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; } 3313 3314 /// Return modifier location. 3315 SourceLocation getModifierLoc() const { return ModifierLoc; } 3316 3317 /// Sets the location of ':'. 3318 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 3319 3320 /// Returns the location of ':'. 3321 SourceLocation getColonLoc() const { return ColonLoc; } 3322 3323 /// Returns linear step. 3324 Expr *getStep() { return *(getFinals().end()); } 3325 3326 /// Returns linear step. 3327 const Expr *getStep() const { return *(getFinals().end()); } 3328 3329 /// Returns expression to calculate linear step. 3330 Expr *getCalcStep() { return *(getFinals().end() + 1); } 3331 3332 /// Returns expression to calculate linear step. 3333 const Expr *getCalcStep() const { return *(getFinals().end() + 1); } 3334 3335 /// Sets the list of update expressions for linear variables. 3336 /// \param UL List of expressions. 3337 void setUpdates(ArrayRef<Expr *> UL); 3338 3339 /// Sets the list of final update expressions for linear variables. 3340 /// \param FL List of expressions. 3341 void setFinals(ArrayRef<Expr *> FL); 3342 3343 /// Sets the list of used expressions for the linear clause. 3344 void setUsedExprs(ArrayRef<Expr *> UE); 3345 3346 using privates_iterator = MutableArrayRef<Expr *>::iterator; 3347 using privates_const_iterator = ArrayRef<const Expr *>::iterator; 3348 using privates_range = llvm::iterator_range<privates_iterator>; 3349 using privates_const_range = llvm::iterator_range<privates_const_iterator>; 3350 3351 privates_range privates() { 3352 return privates_range(getPrivates().begin(), getPrivates().end()); 3353 } 3354 3355 privates_const_range privates() const { 3356 return privates_const_range(getPrivates().begin(), getPrivates().end()); 3357 } 3358 3359 using inits_iterator = MutableArrayRef<Expr *>::iterator; 3360 using inits_const_iterator = ArrayRef<const Expr *>::iterator; 3361 using inits_range = llvm::iterator_range<inits_iterator>; 3362 using inits_const_range = llvm::iterator_range<inits_const_iterator>; 3363 3364 inits_range inits() { 3365 return inits_range(getInits().begin(), getInits().end()); 3366 } 3367 3368 inits_const_range inits() const { 3369 return inits_const_range(getInits().begin(), getInits().end()); 3370 } 3371 3372 using updates_iterator = MutableArrayRef<Expr *>::iterator; 3373 using updates_const_iterator = ArrayRef<const Expr *>::iterator; 3374 using updates_range = llvm::iterator_range<updates_iterator>; 3375 using updates_const_range = llvm::iterator_range<updates_const_iterator>; 3376 3377 updates_range updates() { 3378 return updates_range(getUpdates().begin(), getUpdates().end()); 3379 } 3380 3381 updates_const_range updates() const { 3382 return updates_const_range(getUpdates().begin(), getUpdates().end()); 3383 } 3384 3385 using finals_iterator = MutableArrayRef<Expr *>::iterator; 3386 using finals_const_iterator = ArrayRef<const Expr *>::iterator; 3387 using finals_range = llvm::iterator_range<finals_iterator>; 3388 using finals_const_range = llvm::iterator_range<finals_const_iterator>; 3389 3390 finals_range finals() { 3391 return finals_range(getFinals().begin(), getFinals().end()); 3392 } 3393 3394 finals_const_range finals() const { 3395 return finals_const_range(getFinals().begin(), getFinals().end()); 3396 } 3397 3398 using used_expressions_iterator = MutableArrayRef<Expr *>::iterator; 3399 using used_expressions_const_iterator = ArrayRef<const Expr *>::iterator; 3400 using used_expressions_range = 3401 llvm::iterator_range<used_expressions_iterator>; 3402 using used_expressions_const_range = 3403 llvm::iterator_range<used_expressions_const_iterator>; 3404 3405 used_expressions_range used_expressions() { 3406 return finals_range(getUsedExprs().begin(), getUsedExprs().end()); 3407 } 3408 3409 used_expressions_const_range used_expressions() const { 3410 return finals_const_range(getUsedExprs().begin(), getUsedExprs().end()); 3411 } 3412 3413 child_range children() { 3414 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3415 reinterpret_cast<Stmt **>(varlist_end())); 3416 } 3417 3418 const_child_range children() const { 3419 auto Children = const_cast<OMPLinearClause *>(this)->children(); 3420 return const_child_range(Children.begin(), Children.end()); 3421 } 3422 3423 child_range used_children(); 3424 3425 const_child_range used_children() const { 3426 auto Children = const_cast<OMPLinearClause *>(this)->used_children(); 3427 return const_child_range(Children.begin(), Children.end()); 3428 } 3429 3430 static bool classof(const OMPClause *T) { 3431 return T->getClauseKind() == OMPC_linear; 3432 } 3433}; 3434 3435/// This represents clause 'aligned' in the '#pragma omp ...' 3436/// directives. 3437/// 3438/// \code 3439/// #pragma omp simd aligned(a,b : 8) 3440/// \endcode 3441/// In this example directive '#pragma omp simd' has clause 'aligned' 3442/// with variables 'a', 'b' and alignment '8'. 3443class OMPAlignedClause final 3444 : public OMPVarListClause<OMPAlignedClause>, 3445 private llvm::TrailingObjects<OMPAlignedClause, Expr *> { 3446 friend class OMPClauseReader; 3447 friend OMPVarListClause; 3448 friend TrailingObjects; 3449 3450 /// Location of ':'. 3451 SourceLocation ColonLoc; 3452 3453 /// Sets the alignment for clause. 3454 void setAlignment(Expr *A) { *varlist_end() = A; } 3455 3456 /// Build 'aligned' clause with given number of variables \a NumVars. 3457 /// 3458 /// \param StartLoc Starting location of the clause. 3459 /// \param LParenLoc Location of '('. 3460 /// \param ColonLoc Location of ':'. 3461 /// \param EndLoc Ending location of the clause. 3462 /// \param NumVars Number of variables. 3463 OMPAlignedClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3464 SourceLocation ColonLoc, SourceLocation EndLoc, 3465 unsigned NumVars) 3466 : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, StartLoc, LParenLoc, 3467 EndLoc, NumVars), 3468 ColonLoc(ColonLoc) {} 3469 3470 /// Build an empty clause. 3471 /// 3472 /// \param NumVars Number of variables. 3473 explicit OMPAlignedClause(unsigned NumVars) 3474 : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, SourceLocation(), 3475 SourceLocation(), SourceLocation(), 3476 NumVars) {} 3477 3478public: 3479 /// Creates clause with a list of variables \a VL and alignment \a A. 3480 /// 3481 /// \param C AST Context. 3482 /// \param StartLoc Starting location of the clause. 3483 /// \param LParenLoc Location of '('. 3484 /// \param ColonLoc Location of ':'. 3485 /// \param EndLoc Ending location of the clause. 3486 /// \param VL List of references to the variables. 3487 /// \param A Alignment. 3488 static OMPAlignedClause *Create(const ASTContext &C, SourceLocation StartLoc, 3489 SourceLocation LParenLoc, 3490 SourceLocation ColonLoc, 3491 SourceLocation EndLoc, ArrayRef<Expr *> VL, 3492 Expr *A); 3493 3494 /// Creates an empty clause with the place for \a NumVars variables. 3495 /// 3496 /// \param C AST context. 3497 /// \param NumVars Number of variables. 3498 static OMPAlignedClause *CreateEmpty(const ASTContext &C, unsigned NumVars); 3499 3500 /// Sets the location of ':'. 3501 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 3502 3503 /// Returns the location of ':'. 3504 SourceLocation getColonLoc() const { return ColonLoc; } 3505 3506 /// Returns alignment. 3507 Expr *getAlignment() { return *varlist_end(); } 3508 3509 /// Returns alignment. 3510 const Expr *getAlignment() const { return *varlist_end(); } 3511 3512 child_range children() { 3513 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3514 reinterpret_cast<Stmt **>(varlist_end())); 3515 } 3516 3517 const_child_range children() const { 3518 auto Children = const_cast<OMPAlignedClause *>(this)->children(); 3519 return const_child_range(Children.begin(), Children.end()); 3520 } 3521 3522 child_range used_children() { 3523 return child_range(child_iterator(), child_iterator()); 3524 } 3525 const_child_range used_children() const { 3526 return const_child_range(const_child_iterator(), const_child_iterator()); 3527 } 3528 3529 static bool classof(const OMPClause *T) { 3530 return T->getClauseKind() == OMPC_aligned; 3531 } 3532}; 3533 3534/// This represents clause 'copyin' in the '#pragma omp ...' directives. 3535/// 3536/// \code 3537/// #pragma omp parallel copyin(a,b) 3538/// \endcode 3539/// In this example directive '#pragma omp parallel' has clause 'copyin' 3540/// with the variables 'a' and 'b'. 3541class OMPCopyinClause final 3542 : public OMPVarListClause<OMPCopyinClause>, 3543 private llvm::TrailingObjects<OMPCopyinClause, Expr *> { 3544 // Class has 3 additional tail allocated arrays: 3545 // 1. List of helper expressions for proper generation of assignment operation 3546 // required for copyin clause. This list represents sources. 3547 // 2. List of helper expressions for proper generation of assignment operation 3548 // required for copyin clause. This list represents destinations. 3549 // 3. List of helper expressions that represents assignment operation: 3550 // \code 3551 // DstExprs = SrcExprs; 3552 // \endcode 3553 // Required for proper codegen of propagation of master's thread values of 3554 // threadprivate variables to local instances of that variables in other 3555 // implicit threads. 3556 3557 friend class OMPClauseReader; 3558 friend OMPVarListClause; 3559 friend TrailingObjects; 3560 3561 /// Build clause with number of variables \a N. 3562 /// 3563 /// \param StartLoc Starting location of the clause. 3564 /// \param LParenLoc Location of '('. 3565 /// \param EndLoc Ending location of the clause. 3566 /// \param N Number of the variables in the clause. 3567 OMPCopyinClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3568 SourceLocation EndLoc, unsigned N) 3569 : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, StartLoc, LParenLoc, 3570 EndLoc, N) {} 3571 3572 /// Build an empty clause. 3573 /// 3574 /// \param N Number of variables. 3575 explicit OMPCopyinClause(unsigned N) 3576 : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, SourceLocation(), 3577 SourceLocation(), SourceLocation(), 3578 N) {} 3579 3580 /// Set list of helper expressions, required for proper codegen of the 3581 /// clause. These expressions represent source expression in the final 3582 /// assignment statement performed by the copyin clause. 3583 void setSourceExprs(ArrayRef<Expr *> SrcExprs); 3584 3585 /// Get the list of helper source expressions. 3586 MutableArrayRef<Expr *> getSourceExprs() { 3587 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 3588 } 3589 ArrayRef<const Expr *> getSourceExprs() const { 3590 return llvm::makeArrayRef(varlist_end(), varlist_size()); 3591 } 3592 3593 /// Set list of helper expressions, required for proper codegen of the 3594 /// clause. These expressions represent destination expression in the final 3595 /// assignment statement performed by the copyin clause. 3596 void setDestinationExprs(ArrayRef<Expr *> DstExprs); 3597 3598 /// Get the list of helper destination expressions. 3599 MutableArrayRef<Expr *> getDestinationExprs() { 3600 return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); 3601 } 3602 ArrayRef<const Expr *> getDestinationExprs() const { 3603 return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); 3604 } 3605 3606 /// Set list of helper assignment expressions, required for proper 3607 /// codegen of the clause. These expressions are assignment expressions that 3608 /// assign source helper expressions to destination helper expressions 3609 /// correspondingly. 3610 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps); 3611 3612 /// Get the list of helper assignment expressions. 3613 MutableArrayRef<Expr *> getAssignmentOps() { 3614 return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); 3615 } 3616 ArrayRef<const Expr *> getAssignmentOps() const { 3617 return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); 3618 } 3619 3620public: 3621 /// Creates clause with a list of variables \a VL. 3622 /// 3623 /// \param C AST context. 3624 /// \param StartLoc Starting location of the clause. 3625 /// \param LParenLoc Location of '('. 3626 /// \param EndLoc Ending location of the clause. 3627 /// \param VL List of references to the variables. 3628 /// \param SrcExprs List of helper expressions for proper generation of 3629 /// assignment operation required for copyin clause. This list represents 3630 /// sources. 3631 /// \param DstExprs List of helper expressions for proper generation of 3632 /// assignment operation required for copyin clause. This list represents 3633 /// destinations. 3634 /// \param AssignmentOps List of helper expressions that represents assignment 3635 /// operation: 3636 /// \code 3637 /// DstExprs = SrcExprs; 3638 /// \endcode 3639 /// Required for proper codegen of propagation of master's thread values of 3640 /// threadprivate variables to local instances of that variables in other 3641 /// implicit threads. 3642 static OMPCopyinClause * 3643 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 3644 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 3645 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps); 3646 3647 /// Creates an empty clause with \a N variables. 3648 /// 3649 /// \param C AST context. 3650 /// \param N The number of variables. 3651 static OMPCopyinClause *CreateEmpty(const ASTContext &C, unsigned N); 3652 3653 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 3654 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 3655 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 3656 using helper_expr_const_range = 3657 llvm::iterator_range<helper_expr_const_iterator>; 3658 3659 helper_expr_const_range source_exprs() const { 3660 return helper_expr_const_range(getSourceExprs().begin(), 3661 getSourceExprs().end()); 3662 } 3663 3664 helper_expr_range source_exprs() { 3665 return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end()); 3666 } 3667 3668 helper_expr_const_range destination_exprs() const { 3669 return helper_expr_const_range(getDestinationExprs().begin(), 3670 getDestinationExprs().end()); 3671 } 3672 3673 helper_expr_range destination_exprs() { 3674 return helper_expr_range(getDestinationExprs().begin(), 3675 getDestinationExprs().end()); 3676 } 3677 3678 helper_expr_const_range assignment_ops() const { 3679 return helper_expr_const_range(getAssignmentOps().begin(), 3680 getAssignmentOps().end()); 3681 } 3682 3683 helper_expr_range assignment_ops() { 3684 return helper_expr_range(getAssignmentOps().begin(), 3685 getAssignmentOps().end()); 3686 } 3687 3688 child_range children() { 3689 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3690 reinterpret_cast<Stmt **>(varlist_end())); 3691 } 3692 3693 const_child_range children() const { 3694 auto Children = const_cast<OMPCopyinClause *>(this)->children(); 3695 return const_child_range(Children.begin(), Children.end()); 3696 } 3697 3698 child_range used_children() { 3699 return child_range(child_iterator(), child_iterator()); 3700 } 3701 const_child_range used_children() const { 3702 return const_child_range(const_child_iterator(), const_child_iterator()); 3703 } 3704 3705 static bool classof(const OMPClause *T) { 3706 return T->getClauseKind() == OMPC_copyin; 3707 } 3708}; 3709 3710/// This represents clause 'copyprivate' in the '#pragma omp ...' 3711/// directives. 3712/// 3713/// \code 3714/// #pragma omp single copyprivate(a,b) 3715/// \endcode 3716/// In this example directive '#pragma omp single' has clause 'copyprivate' 3717/// with the variables 'a' and 'b'. 3718class OMPCopyprivateClause final 3719 : public OMPVarListClause<OMPCopyprivateClause>, 3720 private llvm::TrailingObjects<OMPCopyprivateClause, Expr *> { 3721 friend class OMPClauseReader; 3722 friend OMPVarListClause; 3723 friend TrailingObjects; 3724 3725 /// Build clause with number of variables \a N. 3726 /// 3727 /// \param StartLoc Starting location of the clause. 3728 /// \param LParenLoc Location of '('. 3729 /// \param EndLoc Ending location of the clause. 3730 /// \param N Number of the variables in the clause. 3731 OMPCopyprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3732 SourceLocation EndLoc, unsigned N) 3733 : OMPVarListClause<OMPCopyprivateClause>(OMPC_copyprivate, StartLoc, 3734 LParenLoc, EndLoc, N) {} 3735 3736 /// Build an empty clause. 3737 /// 3738 /// \param N Number of variables. 3739 explicit OMPCopyprivateClause(unsigned N) 3740 : OMPVarListClause<OMPCopyprivateClause>( 3741 OMPC_copyprivate, SourceLocation(), SourceLocation(), 3742 SourceLocation(), N) {} 3743 3744 /// Set list of helper expressions, required for proper codegen of the 3745 /// clause. These expressions represent source expression in the final 3746 /// assignment statement performed by the copyprivate clause. 3747 void setSourceExprs(ArrayRef<Expr *> SrcExprs); 3748 3749 /// Get the list of helper source expressions. 3750 MutableArrayRef<Expr *> getSourceExprs() { 3751 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 3752 } 3753 ArrayRef<const Expr *> getSourceExprs() const { 3754 return llvm::makeArrayRef(varlist_end(), varlist_size()); 3755 } 3756 3757 /// Set list of helper expressions, required for proper codegen of the 3758 /// clause. These expressions represent destination expression in the final 3759 /// assignment statement performed by the copyprivate clause. 3760 void setDestinationExprs(ArrayRef<Expr *> DstExprs); 3761 3762 /// Get the list of helper destination expressions. 3763 MutableArrayRef<Expr *> getDestinationExprs() { 3764 return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size()); 3765 } 3766 ArrayRef<const Expr *> getDestinationExprs() const { 3767 return llvm::makeArrayRef(getSourceExprs().end(), varlist_size()); 3768 } 3769 3770 /// Set list of helper assignment expressions, required for proper 3771 /// codegen of the clause. These expressions are assignment expressions that 3772 /// assign source helper expressions to destination helper expressions 3773 /// correspondingly. 3774 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps); 3775 3776 /// Get the list of helper assignment expressions. 3777 MutableArrayRef<Expr *> getAssignmentOps() { 3778 return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size()); 3779 } 3780 ArrayRef<const Expr *> getAssignmentOps() const { 3781 return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size()); 3782 } 3783 3784public: 3785 /// Creates clause with a list of variables \a VL. 3786 /// 3787 /// \param C AST context. 3788 /// \param StartLoc Starting location of the clause. 3789 /// \param LParenLoc Location of '('. 3790 /// \param EndLoc Ending location of the clause. 3791 /// \param VL List of references to the variables. 3792 /// \param SrcExprs List of helper expressions for proper generation of 3793 /// assignment operation required for copyprivate clause. This list represents 3794 /// sources. 3795 /// \param DstExprs List of helper expressions for proper generation of 3796 /// assignment operation required for copyprivate clause. This list represents 3797 /// destinations. 3798 /// \param AssignmentOps List of helper expressions that represents assignment 3799 /// operation: 3800 /// \code 3801 /// DstExprs = SrcExprs; 3802 /// \endcode 3803 /// Required for proper codegen of final assignment performed by the 3804 /// copyprivate clause. 3805 static OMPCopyprivateClause * 3806 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 3807 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 3808 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps); 3809 3810 /// Creates an empty clause with \a N variables. 3811 /// 3812 /// \param C AST context. 3813 /// \param N The number of variables. 3814 static OMPCopyprivateClause *CreateEmpty(const ASTContext &C, unsigned N); 3815 3816 using helper_expr_iterator = MutableArrayRef<Expr *>::iterator; 3817 using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator; 3818 using helper_expr_range = llvm::iterator_range<helper_expr_iterator>; 3819 using helper_expr_const_range = 3820 llvm::iterator_range<helper_expr_const_iterator>; 3821 3822 helper_expr_const_range source_exprs() const { 3823 return helper_expr_const_range(getSourceExprs().begin(), 3824 getSourceExprs().end()); 3825 } 3826 3827 helper_expr_range source_exprs() { 3828 return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end()); 3829 } 3830 3831 helper_expr_const_range destination_exprs() const { 3832 return helper_expr_const_range(getDestinationExprs().begin(), 3833 getDestinationExprs().end()); 3834 } 3835 3836 helper_expr_range destination_exprs() { 3837 return helper_expr_range(getDestinationExprs().begin(), 3838 getDestinationExprs().end()); 3839 } 3840 3841 helper_expr_const_range assignment_ops() const { 3842 return helper_expr_const_range(getAssignmentOps().begin(), 3843 getAssignmentOps().end()); 3844 } 3845 3846 helper_expr_range assignment_ops() { 3847 return helper_expr_range(getAssignmentOps().begin(), 3848 getAssignmentOps().end()); 3849 } 3850 3851 child_range children() { 3852 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3853 reinterpret_cast<Stmt **>(varlist_end())); 3854 } 3855 3856 const_child_range children() const { 3857 auto Children = const_cast<OMPCopyprivateClause *>(this)->children(); 3858 return const_child_range(Children.begin(), Children.end()); 3859 } 3860 3861 child_range used_children() { 3862 return child_range(child_iterator(), child_iterator()); 3863 } 3864 const_child_range used_children() const { 3865 return const_child_range(const_child_iterator(), const_child_iterator()); 3866 } 3867 3868 static bool classof(const OMPClause *T) { 3869 return T->getClauseKind() == OMPC_copyprivate; 3870 } 3871}; 3872 3873/// This represents implicit clause 'flush' for the '#pragma omp flush' 3874/// directive. 3875/// This clause does not exist by itself, it can be only as a part of 'omp 3876/// flush' directive. This clause is introduced to keep the original structure 3877/// of \a OMPExecutableDirective class and its derivatives and to use the 3878/// existing infrastructure of clauses with the list of variables. 3879/// 3880/// \code 3881/// #pragma omp flush(a,b) 3882/// \endcode 3883/// In this example directive '#pragma omp flush' has implicit clause 'flush' 3884/// with the variables 'a' and 'b'. 3885class OMPFlushClause final 3886 : public OMPVarListClause<OMPFlushClause>, 3887 private llvm::TrailingObjects<OMPFlushClause, Expr *> { 3888 friend OMPVarListClause; 3889 friend TrailingObjects; 3890 3891 /// Build clause with number of variables \a N. 3892 /// 3893 /// \param StartLoc Starting location of the clause. 3894 /// \param LParenLoc Location of '('. 3895 /// \param EndLoc Ending location of the clause. 3896 /// \param N Number of the variables in the clause. 3897 OMPFlushClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3898 SourceLocation EndLoc, unsigned N) 3899 : OMPVarListClause<OMPFlushClause>(OMPC_flush, StartLoc, LParenLoc, 3900 EndLoc, N) {} 3901 3902 /// Build an empty clause. 3903 /// 3904 /// \param N Number of variables. 3905 explicit OMPFlushClause(unsigned N) 3906 : OMPVarListClause<OMPFlushClause>(OMPC_flush, SourceLocation(), 3907 SourceLocation(), SourceLocation(), 3908 N) {} 3909 3910public: 3911 /// Creates clause with a list of variables \a VL. 3912 /// 3913 /// \param C AST context. 3914 /// \param StartLoc Starting location of the clause. 3915 /// \param LParenLoc Location of '('. 3916 /// \param EndLoc Ending location of the clause. 3917 /// \param VL List of references to the variables. 3918 static OMPFlushClause *Create(const ASTContext &C, SourceLocation StartLoc, 3919 SourceLocation LParenLoc, SourceLocation EndLoc, 3920 ArrayRef<Expr *> VL); 3921 3922 /// Creates an empty clause with \a N variables. 3923 /// 3924 /// \param C AST context. 3925 /// \param N The number of variables. 3926 static OMPFlushClause *CreateEmpty(const ASTContext &C, unsigned N); 3927 3928 child_range children() { 3929 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 3930 reinterpret_cast<Stmt **>(varlist_end())); 3931 } 3932 3933 const_child_range children() const { 3934 auto Children = const_cast<OMPFlushClause *>(this)->children(); 3935 return const_child_range(Children.begin(), Children.end()); 3936 } 3937 3938 child_range used_children() { 3939 return child_range(child_iterator(), child_iterator()); 3940 } 3941 const_child_range used_children() const { 3942 return const_child_range(const_child_iterator(), const_child_iterator()); 3943 } 3944 3945 static bool classof(const OMPClause *T) { 3946 return T->getClauseKind() == OMPC_flush; 3947 } 3948}; 3949 3950/// This represents implicit clause 'depend' for the '#pragma omp task' 3951/// directive. 3952/// 3953/// \code 3954/// #pragma omp task depend(in:a,b) 3955/// \endcode 3956/// In this example directive '#pragma omp task' with clause 'depend' with the 3957/// variables 'a' and 'b' with dependency 'in'. 3958class OMPDependClause final 3959 : public OMPVarListClause<OMPDependClause>, 3960 private llvm::TrailingObjects<OMPDependClause, Expr *> { 3961 friend class OMPClauseReader; 3962 friend OMPVarListClause; 3963 friend TrailingObjects; 3964 3965 /// Dependency type (one of in, out, inout). 3966 OpenMPDependClauseKind DepKind = OMPC_DEPEND_unknown; 3967 3968 /// Dependency type location. 3969 SourceLocation DepLoc; 3970 3971 /// Colon location. 3972 SourceLocation ColonLoc; 3973 3974 /// Number of loops, associated with the depend clause. 3975 unsigned NumLoops = 0; 3976 3977 /// Build clause with number of variables \a N. 3978 /// 3979 /// \param StartLoc Starting location of the clause. 3980 /// \param LParenLoc Location of '('. 3981 /// \param EndLoc Ending location of the clause. 3982 /// \param N Number of the variables in the clause. 3983 /// \param NumLoops Number of loops that is associated with this depend 3984 /// clause. 3985 OMPDependClause(SourceLocation StartLoc, SourceLocation LParenLoc, 3986 SourceLocation EndLoc, unsigned N, unsigned NumLoops) 3987 : OMPVarListClause<OMPDependClause>(OMPC_depend, StartLoc, LParenLoc, 3988 EndLoc, N), NumLoops(NumLoops) {} 3989 3990 /// Build an empty clause. 3991 /// 3992 /// \param N Number of variables. 3993 /// \param NumLoops Number of loops that is associated with this depend 3994 /// clause. 3995 explicit OMPDependClause(unsigned N, unsigned NumLoops) 3996 : OMPVarListClause<OMPDependClause>(OMPC_depend, SourceLocation(), 3997 SourceLocation(), SourceLocation(), 3998 N), 3999 NumLoops(NumLoops) {} 4000 4001 /// Set dependency kind. 4002 void setDependencyKind(OpenMPDependClauseKind K) { DepKind = K; } 4003 4004 /// Set dependency kind and its location. 4005 void setDependencyLoc(SourceLocation Loc) { DepLoc = Loc; } 4006 4007 /// Set colon location. 4008 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 4009 4010public: 4011 /// Creates clause with a list of variables \a VL. 4012 /// 4013 /// \param C AST context. 4014 /// \param StartLoc Starting location of the clause. 4015 /// \param LParenLoc Location of '('. 4016 /// \param EndLoc Ending location of the clause. 4017 /// \param DepKind Dependency type. 4018 /// \param DepLoc Location of the dependency type. 4019 /// \param ColonLoc Colon location. 4020 /// \param VL List of references to the variables. 4021 /// \param NumLoops Number of loops that is associated with this depend 4022 /// clause. 4023 static OMPDependClause *Create(const ASTContext &C, SourceLocation StartLoc, 4024 SourceLocation LParenLoc, 4025 SourceLocation EndLoc, 4026 OpenMPDependClauseKind DepKind, 4027 SourceLocation DepLoc, SourceLocation ColonLoc, 4028 ArrayRef<Expr *> VL, unsigned NumLoops); 4029 4030 /// Creates an empty clause with \a N variables. 4031 /// 4032 /// \param C AST context. 4033 /// \param N The number of variables. 4034 /// \param NumLoops Number of loops that is associated with this depend 4035 /// clause. 4036 static OMPDependClause *CreateEmpty(const ASTContext &C, unsigned N, 4037 unsigned NumLoops); 4038 4039 /// Get dependency type. 4040 OpenMPDependClauseKind getDependencyKind() const { return DepKind; } 4041 4042 /// Get dependency type location. 4043 SourceLocation getDependencyLoc() const { return DepLoc; } 4044 4045 /// Get colon location. 4046 SourceLocation getColonLoc() const { return ColonLoc; } 4047 4048 /// Get number of loops associated with the clause. 4049 unsigned getNumLoops() const { return NumLoops; } 4050 4051 /// Set the loop data for the depend clauses with 'sink|source' kind of 4052 /// dependency. 4053 void setLoopData(unsigned NumLoop, Expr *Cnt); 4054 4055 /// Get the loop data. 4056 Expr *getLoopData(unsigned NumLoop); 4057 const Expr *getLoopData(unsigned NumLoop) const; 4058 4059 child_range children() { 4060 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 4061 reinterpret_cast<Stmt **>(varlist_end())); 4062 } 4063 4064 const_child_range children() const { 4065 auto Children = const_cast<OMPDependClause *>(this)->children(); 4066 return const_child_range(Children.begin(), Children.end()); 4067 } 4068 4069 child_range used_children() { 4070 return child_range(child_iterator(), child_iterator()); 4071 } 4072 const_child_range used_children() const { 4073 return const_child_range(const_child_iterator(), const_child_iterator()); 4074 } 4075 4076 static bool classof(const OMPClause *T) { 4077 return T->getClauseKind() == OMPC_depend; 4078 } 4079}; 4080 4081/// This represents 'device' clause in the '#pragma omp ...' 4082/// directive. 4083/// 4084/// \code 4085/// #pragma omp target device(a) 4086/// \endcode 4087/// In this example directive '#pragma omp target' has clause 'device' 4088/// with single expression 'a'. 4089class OMPDeviceClause : public OMPClause, public OMPClauseWithPreInit { 4090 friend class OMPClauseReader; 4091 4092 /// Location of '('. 4093 SourceLocation LParenLoc; 4094 4095 /// Device number. 4096 Stmt *Device = nullptr; 4097 4098 /// Set the device number. 4099 /// 4100 /// \param E Device number. 4101 void setDevice(Expr *E) { Device = E; } 4102 4103public: 4104 /// Build 'device' clause. 4105 /// 4106 /// \param E Expression associated with this clause. 4107 /// \param CaptureRegion Innermost OpenMP region where expressions in this 4108 /// clause must be captured. 4109 /// \param StartLoc Starting location of the clause. 4110 /// \param LParenLoc Location of '('. 4111 /// \param EndLoc Ending location of the clause. 4112 OMPDeviceClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion, 4113 SourceLocation StartLoc, SourceLocation LParenLoc, 4114 SourceLocation EndLoc) 4115 : OMPClause(OMPC_device, StartLoc, EndLoc), OMPClauseWithPreInit(this), 4116 LParenLoc(LParenLoc), Device(E) { 4117 setPreInitStmt(HelperE, CaptureRegion); 4118 } 4119 4120 /// Build an empty clause. 4121 OMPDeviceClause() 4122 : OMPClause(OMPC_device, SourceLocation(), SourceLocation()), 4123 OMPClauseWithPreInit(this) {} 4124 4125 /// Sets the location of '('. 4126 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 4127 4128 /// Returns the location of '('. 4129 SourceLocation getLParenLoc() const { return LParenLoc; } 4130 4131 /// Return device number. 4132 Expr *getDevice() { return cast<Expr>(Device); } 4133 4134 /// Return device number. 4135 Expr *getDevice() const { return cast<Expr>(Device); } 4136 4137 child_range children() { return child_range(&Device, &Device + 1); } 4138 4139 const_child_range children() const { 4140 return const_child_range(&Device, &Device + 1); 4141 } 4142 4143 child_range used_children() { 4144 return child_range(child_iterator(), child_iterator()); 4145 } 4146 const_child_range used_children() const { 4147 return const_child_range(const_child_iterator(), const_child_iterator()); 4148 } 4149 4150 static bool classof(const OMPClause *T) { 4151 return T->getClauseKind() == OMPC_device; 4152 } 4153}; 4154 4155/// This represents 'threads' clause in the '#pragma omp ...' directive. 4156/// 4157/// \code 4158/// #pragma omp ordered threads 4159/// \endcode 4160/// In this example directive '#pragma omp ordered' has simple 'threads' clause. 4161class OMPThreadsClause : public OMPClause { 4162public: 4163 /// Build 'threads' clause. 4164 /// 4165 /// \param StartLoc Starting location of the clause. 4166 /// \param EndLoc Ending location of the clause. 4167 OMPThreadsClause(SourceLocation StartLoc, SourceLocation EndLoc) 4168 : OMPClause(OMPC_threads, StartLoc, EndLoc) {} 4169 4170 /// Build an empty clause. 4171 OMPThreadsClause() 4172 : OMPClause(OMPC_threads, SourceLocation(), SourceLocation()) {} 4173 4174 child_range children() { 4175 return child_range(child_iterator(), child_iterator()); 4176 } 4177 4178 const_child_range children() const { 4179 return const_child_range(const_child_iterator(), const_child_iterator()); 4180 } 4181 4182 child_range used_children() { 4183 return child_range(child_iterator(), child_iterator()); 4184 } 4185 const_child_range used_children() const { 4186 return const_child_range(const_child_iterator(), const_child_iterator()); 4187 } 4188 4189 static bool classof(const OMPClause *T) { 4190 return T->getClauseKind() == OMPC_threads; 4191 } 4192}; 4193 4194/// This represents 'simd' clause in the '#pragma omp ...' directive. 4195/// 4196/// \code 4197/// #pragma omp ordered simd 4198/// \endcode 4199/// In this example directive '#pragma omp ordered' has simple 'simd' clause. 4200class OMPSIMDClause : public OMPClause { 4201public: 4202 /// Build 'simd' clause. 4203 /// 4204 /// \param StartLoc Starting location of the clause. 4205 /// \param EndLoc Ending location of the clause. 4206 OMPSIMDClause(SourceLocation StartLoc, SourceLocation EndLoc) 4207 : OMPClause(OMPC_simd, StartLoc, EndLoc) {} 4208 4209 /// Build an empty clause. 4210 OMPSIMDClause() : OMPClause(OMPC_simd, SourceLocation(), SourceLocation()) {} 4211 4212 child_range children() { 4213 return child_range(child_iterator(), child_iterator()); 4214 } 4215 4216 const_child_range children() const { 4217 return const_child_range(const_child_iterator(), const_child_iterator()); 4218 } 4219 4220 child_range used_children() { 4221 return child_range(child_iterator(), child_iterator()); 4222 } 4223 const_child_range used_children() const { 4224 return const_child_range(const_child_iterator(), const_child_iterator()); 4225 } 4226 4227 static bool classof(const OMPClause *T) { 4228 return T->getClauseKind() == OMPC_simd; 4229 } 4230}; 4231 4232/// Struct that defines common infrastructure to handle mappable 4233/// expressions used in OpenMP clauses. 4234class OMPClauseMappableExprCommon { 4235public: 4236 /// Class that represents a component of a mappable expression. E.g. 4237 /// for an expression S.a, the first component is a declaration reference 4238 /// expression associated with 'S' and the second is a member expression 4239 /// associated with the field declaration 'a'. If the expression is an array 4240 /// subscript it may not have any associated declaration. In that case the 4241 /// associated declaration is set to nullptr. 4242 class MappableComponent { 4243 /// Expression associated with the component. 4244 Expr *AssociatedExpression = nullptr; 4245 4246 /// Declaration associated with the declaration. If the component does 4247 /// not have a declaration (e.g. array subscripts or section), this is set 4248 /// to nullptr. 4249 ValueDecl *AssociatedDeclaration = nullptr; 4250 4251 public: 4252 explicit MappableComponent() = default; 4253 explicit MappableComponent(Expr *AssociatedExpression, 4254 ValueDecl *AssociatedDeclaration) 4255 : AssociatedExpression(AssociatedExpression), 4256 AssociatedDeclaration( 4257 AssociatedDeclaration 4258 ? cast<ValueDecl>(AssociatedDeclaration->getCanonicalDecl()) 4259 : nullptr) {} 4260 4261 Expr *getAssociatedExpression() const { return AssociatedExpression; } 4262 4263 ValueDecl *getAssociatedDeclaration() const { 4264 return AssociatedDeclaration; 4265 } 4266 }; 4267 4268 // List of components of an expression. This first one is the whole 4269 // expression and the last one is the base expression. 4270 using MappableExprComponentList = SmallVector<MappableComponent, 8>; 4271 using MappableExprComponentListRef = ArrayRef<MappableComponent>; 4272 4273 // List of all component lists associated to the same base declaration. 4274 // E.g. if both 'S.a' and 'S.b' are a mappable expressions, each will have 4275 // their component list but the same base declaration 'S'. 4276 using MappableExprComponentLists = SmallVector<MappableExprComponentList, 8>; 4277 using MappableExprComponentListsRef = ArrayRef<MappableExprComponentList>; 4278 4279protected: 4280 // Return the total number of elements in a list of component lists. 4281 static unsigned 4282 getComponentsTotalNumber(MappableExprComponentListsRef ComponentLists); 4283 4284 // Return the total number of elements in a list of declarations. All 4285 // declarations are expected to be canonical. 4286 static unsigned 4287 getUniqueDeclarationsTotalNumber(ArrayRef<const ValueDecl *> Declarations); 4288}; 4289 4290/// This structure contains all sizes needed for by an 4291/// OMPMappableExprListClause. 4292struct OMPMappableExprListSizeTy { 4293 /// Number of expressions listed. 4294 unsigned NumVars; 4295 /// Number of unique base declarations. 4296 unsigned NumUniqueDeclarations; 4297 /// Number of component lists. 4298 unsigned NumComponentLists; 4299 /// Total number of expression components. 4300 unsigned NumComponents; 4301 OMPMappableExprListSizeTy() = default; 4302 OMPMappableExprListSizeTy(unsigned NumVars, unsigned NumUniqueDeclarations, 4303 unsigned NumComponentLists, unsigned NumComponents) 4304 : NumVars(NumVars), NumUniqueDeclarations(NumUniqueDeclarations), 4305 NumComponentLists(NumComponentLists), NumComponents(NumComponents) {} 4306}; 4307 4308/// This represents clauses with a list of expressions that are mappable. 4309/// Examples of these clauses are 'map' in 4310/// '#pragma omp target [enter|exit] [data]...' directives, and 'to' and 'from 4311/// in '#pragma omp target update...' directives. 4312template <class T> 4313class OMPMappableExprListClause : public OMPVarListClause<T>, 4314 public OMPClauseMappableExprCommon { 4315 friend class OMPClauseReader; 4316 4317 /// Number of unique declarations in this clause. 4318 unsigned NumUniqueDeclarations; 4319 4320 /// Number of component lists in this clause. 4321 unsigned NumComponentLists; 4322 4323 /// Total number of components in this clause. 4324 unsigned NumComponents; 4325 4326 /// C++ nested name specifier for the associated user-defined mapper. 4327 NestedNameSpecifierLoc MapperQualifierLoc; 4328 4329 /// The associated user-defined mapper identifier information. 4330 DeclarationNameInfo MapperIdInfo; 4331 4332protected: 4333 /// Build a clause for \a NumUniqueDeclarations declarations, \a 4334 /// NumComponentLists total component lists, and \a NumComponents total 4335 /// components. 4336 /// 4337 /// \param K Kind of the clause. 4338 /// \param Locs Locations needed to build a mappable clause. It includes 1) 4339 /// StartLoc: starting location of the clause (the clause keyword); 2) 4340 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 4341 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 4342 /// NumVars: number of expressions listed in this clause; 2) 4343 /// NumUniqueDeclarations: number of unique base declarations in this clause; 4344 /// 3) NumComponentLists: number of component lists in this clause; and 4) 4345 /// NumComponents: total number of expression components in the clause. 4346 /// \param MapperQualifierLocPtr C++ nested name specifier for the associated 4347 /// user-defined mapper. 4348 /// \param MapperIdInfoPtr The identifier of associated user-defined mapper. 4349 OMPMappableExprListClause( 4350 OpenMPClauseKind K, const OMPVarListLocTy &Locs, 4351 const OMPMappableExprListSizeTy &Sizes, 4352 NestedNameSpecifierLoc *MapperQualifierLocPtr = nullptr, 4353 DeclarationNameInfo *MapperIdInfoPtr = nullptr) 4354 : OMPVarListClause<T>(K, Locs.StartLoc, Locs.LParenLoc, Locs.EndLoc, 4355 Sizes.NumVars), 4356 NumUniqueDeclarations(Sizes.NumUniqueDeclarations), 4357 NumComponentLists(Sizes.NumComponentLists), 4358 NumComponents(Sizes.NumComponents) { 4359 if (MapperQualifierLocPtr) 4360 MapperQualifierLoc = *MapperQualifierLocPtr; 4361 if (MapperIdInfoPtr) 4362 MapperIdInfo = *MapperIdInfoPtr; 4363 } 4364 4365 /// Get the unique declarations that are in the trailing objects of the 4366 /// class. 4367 MutableArrayRef<ValueDecl *> getUniqueDeclsRef() { 4368 return MutableArrayRef<ValueDecl *>( 4369 static_cast<T *>(this)->template getTrailingObjects<ValueDecl *>(), 4370 NumUniqueDeclarations); 4371 } 4372 4373 /// Get the unique declarations that are in the trailing objects of the 4374 /// class. 4375 ArrayRef<ValueDecl *> getUniqueDeclsRef() const { 4376 return ArrayRef<ValueDecl *>( 4377 static_cast<const T *>(this) 4378 ->template getTrailingObjects<ValueDecl *>(), 4379 NumUniqueDeclarations); 4380 } 4381 4382 /// Set the unique declarations that are in the trailing objects of the 4383 /// class. 4384 void setUniqueDecls(ArrayRef<ValueDecl *> UDs) { 4385 assert(UDs.size() == NumUniqueDeclarations && 4386 "Unexpected amount of unique declarations."); 4387 std::copy(UDs.begin(), UDs.end(), getUniqueDeclsRef().begin()); 4388 } 4389 4390 /// Get the number of lists per declaration that are in the trailing 4391 /// objects of the class. 4392 MutableArrayRef<unsigned> getDeclNumListsRef() { 4393 return MutableArrayRef<unsigned>( 4394 static_cast<T *>(this)->template getTrailingObjects<unsigned>(), 4395 NumUniqueDeclarations); 4396 } 4397 4398 /// Get the number of lists per declaration that are in the trailing 4399 /// objects of the class. 4400 ArrayRef<unsigned> getDeclNumListsRef() const { 4401 return ArrayRef<unsigned>( 4402 static_cast<const T *>(this)->template getTrailingObjects<unsigned>(), 4403 NumUniqueDeclarations); 4404 } 4405 4406 /// Set the number of lists per declaration that are in the trailing 4407 /// objects of the class. 4408 void setDeclNumLists(ArrayRef<unsigned> DNLs) { 4409 assert(DNLs.size() == NumUniqueDeclarations && 4410 "Unexpected amount of list numbers."); 4411 std::copy(DNLs.begin(), DNLs.end(), getDeclNumListsRef().begin()); 4412 } 4413 4414 /// Get the cumulative component lists sizes that are in the trailing 4415 /// objects of the class. They are appended after the number of lists. 4416 MutableArrayRef<unsigned> getComponentListSizesRef() { 4417 return MutableArrayRef<unsigned>( 4418 static_cast<T *>(this)->template getTrailingObjects<unsigned>() + 4419 NumUniqueDeclarations, 4420 NumComponentLists); 4421 } 4422 4423 /// Get the cumulative component lists sizes that are in the trailing 4424 /// objects of the class. They are appended after the number of lists. 4425 ArrayRef<unsigned> getComponentListSizesRef() const { 4426 return ArrayRef<unsigned>( 4427 static_cast<const T *>(this)->template getTrailingObjects<unsigned>() + 4428 NumUniqueDeclarations, 4429 NumComponentLists); 4430 } 4431 4432 /// Set the cumulative component lists sizes that are in the trailing 4433 /// objects of the class. 4434 void setComponentListSizes(ArrayRef<unsigned> CLSs) { 4435 assert(CLSs.size() == NumComponentLists && 4436 "Unexpected amount of component lists."); 4437 std::copy(CLSs.begin(), CLSs.end(), getComponentListSizesRef().begin()); 4438 } 4439 4440 /// Get the components that are in the trailing objects of the class. 4441 MutableArrayRef<MappableComponent> getComponentsRef() { 4442 return MutableArrayRef<MappableComponent>( 4443 static_cast<T *>(this) 4444 ->template getTrailingObjects<MappableComponent>(), 4445 NumComponents); 4446 } 4447 4448 /// Get the components that are in the trailing objects of the class. 4449 ArrayRef<MappableComponent> getComponentsRef() const { 4450 return ArrayRef<MappableComponent>( 4451 static_cast<const T *>(this) 4452 ->template getTrailingObjects<MappableComponent>(), 4453 NumComponents); 4454 } 4455 4456 /// Set the components that are in the trailing objects of the class. 4457 /// This requires the list sizes so that it can also fill the original 4458 /// expressions, which are the first component of each list. 4459 void setComponents(ArrayRef<MappableComponent> Components, 4460 ArrayRef<unsigned> CLSs) { 4461 assert(Components.size() == NumComponents && 4462 "Unexpected amount of component lists."); 4463 assert(CLSs.size() == NumComponentLists && 4464 "Unexpected amount of list sizes."); 4465 std::copy(Components.begin(), Components.end(), getComponentsRef().begin()); 4466 } 4467 4468 /// Fill the clause information from the list of declarations and 4469 /// associated component lists. 4470 void setClauseInfo(ArrayRef<ValueDecl *> Declarations, 4471 MappableExprComponentListsRef ComponentLists) { 4472 // Perform some checks to make sure the data sizes are consistent with the 4473 // information available when the clause was created. 4474 assert(getUniqueDeclarationsTotalNumber(Declarations) == 4475 NumUniqueDeclarations && 4476 "Unexpected number of mappable expression info entries!"); 4477 assert(getComponentsTotalNumber(ComponentLists) == NumComponents && 4478 "Unexpected total number of components!"); 4479 assert(Declarations.size() == ComponentLists.size() && 4480 "Declaration and component lists size is not consistent!"); 4481 assert(Declarations.size() == NumComponentLists && 4482 "Unexpected declaration and component lists size!"); 4483 4484 // Organize the components by declaration and retrieve the original 4485 // expression. Original expressions are always the first component of the 4486 // mappable component list. 4487 llvm::MapVector<ValueDecl *, SmallVector<MappableExprComponentListRef, 8>> 4488 ComponentListMap; 4489 { 4490 auto CI = ComponentLists.begin(); 4491 for (auto DI = Declarations.begin(), DE = Declarations.end(); DI != DE; 4492 ++DI, ++CI) { 4493 assert(!CI->empty() && "Invalid component list!"); 4494 ComponentListMap[*DI].push_back(*CI); 4495 } 4496 } 4497 4498 // Iterators of the target storage. 4499 auto UniqueDeclarations = getUniqueDeclsRef(); 4500 auto UDI = UniqueDeclarations.begin(); 4501 4502 auto DeclNumLists = getDeclNumListsRef(); 4503 auto DNLI = DeclNumLists.begin(); 4504 4505 auto ComponentListSizes = getComponentListSizesRef(); 4506 auto CLSI = ComponentListSizes.begin(); 4507 4508 auto Components = getComponentsRef(); 4509 auto CI = Components.begin(); 4510 4511 // Variable to compute the accumulation of the number of components. 4512 unsigned PrevSize = 0u; 4513 4514 // Scan all the declarations and associated component lists. 4515 for (auto &M : ComponentListMap) { 4516 // The declaration. 4517 auto *D = M.first; 4518 // The component lists. 4519 auto CL = M.second; 4520 4521 // Initialize the entry. 4522 *UDI = D; 4523 ++UDI; 4524 4525 *DNLI = CL.size(); 4526 ++DNLI; 4527 4528 // Obtain the cumulative sizes and concatenate all the components in the 4529 // reserved storage. 4530 for (auto C : CL) { 4531 // Accumulate with the previous size. 4532 PrevSize += C.size(); 4533 4534 // Save the size. 4535 *CLSI = PrevSize; 4536 ++CLSI; 4537 4538 // Append components after the current components iterator. 4539 CI = std::copy(C.begin(), C.end(), CI); 4540 } 4541 } 4542 } 4543 4544 /// Set the nested name specifier of associated user-defined mapper. 4545 void setMapperQualifierLoc(NestedNameSpecifierLoc NNSL) { 4546 MapperQualifierLoc = NNSL; 4547 } 4548 4549 /// Set the name of associated user-defined mapper. 4550 void setMapperIdInfo(DeclarationNameInfo MapperId) { 4551 MapperIdInfo = MapperId; 4552 } 4553 4554 /// Get the user-defined mapper references that are in the trailing objects of 4555 /// the class. 4556 MutableArrayRef<Expr *> getUDMapperRefs() { 4557 return llvm::makeMutableArrayRef<Expr *>( 4558 static_cast<T *>(this)->template getTrailingObjects<Expr *>() + 4559 OMPVarListClause<T>::varlist_size(), 4560 OMPVarListClause<T>::varlist_size()); 4561 } 4562 4563 /// Get the user-defined mappers references that are in the trailing objects 4564 /// of the class. 4565 ArrayRef<Expr *> getUDMapperRefs() const { 4566 return llvm::makeArrayRef<Expr *>( 4567 static_cast<T *>(this)->template getTrailingObjects<Expr *>() + 4568 OMPVarListClause<T>::varlist_size(), 4569 OMPVarListClause<T>::varlist_size()); 4570 } 4571 4572 /// Set the user-defined mappers that are in the trailing objects of the 4573 /// class. 4574 void setUDMapperRefs(ArrayRef<Expr *> DMDs) { 4575 assert(DMDs.size() == OMPVarListClause<T>::varlist_size() && 4576 "Unexpected number of user-defined mappers."); 4577 std::copy(DMDs.begin(), DMDs.end(), getUDMapperRefs().begin()); 4578 } 4579 4580public: 4581 /// Return the number of unique base declarations in this clause. 4582 unsigned getUniqueDeclarationsNum() const { return NumUniqueDeclarations; } 4583 4584 /// Return the number of lists derived from the clause expressions. 4585 unsigned getTotalComponentListNum() const { return NumComponentLists; } 4586 4587 /// Return the total number of components in all lists derived from the 4588 /// clause. 4589 unsigned getTotalComponentsNum() const { return NumComponents; } 4590 4591 /// Gets the nested name specifier for associated user-defined mapper. 4592 NestedNameSpecifierLoc getMapperQualifierLoc() const { 4593 return MapperQualifierLoc; 4594 } 4595 4596 /// Gets the name info for associated user-defined mapper. 4597 const DeclarationNameInfo &getMapperIdInfo() const { return MapperIdInfo; } 4598 4599 /// Iterator that browse the components by lists. It also allows 4600 /// browsing components of a single declaration. 4601 class const_component_lists_iterator 4602 : public llvm::iterator_adaptor_base< 4603 const_component_lists_iterator, 4604 MappableExprComponentListRef::const_iterator, 4605 std::forward_iterator_tag, MappableComponent, ptrdiff_t, 4606 MappableComponent, MappableComponent> { 4607 // The declaration the iterator currently refers to. 4608 ArrayRef<ValueDecl *>::iterator DeclCur; 4609 4610 // The list number associated with the current declaration. 4611 ArrayRef<unsigned>::iterator NumListsCur; 4612 4613 // Remaining lists for the current declaration. 4614 unsigned RemainingLists = 0; 4615 4616 // The cumulative size of the previous list, or zero if there is no previous 4617 // list. 4618 unsigned PrevListSize = 0; 4619 4620 // The cumulative sizes of the current list - it will delimit the remaining 4621 // range of interest. 4622 ArrayRef<unsigned>::const_iterator ListSizeCur; 4623 ArrayRef<unsigned>::const_iterator ListSizeEnd; 4624 4625 // Iterator to the end of the components storage. 4626 MappableExprComponentListRef::const_iterator End; 4627 4628 public: 4629 /// Construct an iterator that scans all lists. 4630 explicit const_component_lists_iterator( 4631 ArrayRef<ValueDecl *> UniqueDecls, ArrayRef<unsigned> DeclsListNum, 4632 ArrayRef<unsigned> CumulativeListSizes, 4633 MappableExprComponentListRef Components) 4634 : const_component_lists_iterator::iterator_adaptor_base( 4635 Components.begin()), 4636 DeclCur(UniqueDecls.begin()), NumListsCur(DeclsListNum.begin()), 4637 ListSizeCur(CumulativeListSizes.begin()), 4638 ListSizeEnd(CumulativeListSizes.end()), End(Components.end()) { 4639 assert(UniqueDecls.size() == DeclsListNum.size() && 4640 "Inconsistent number of declarations and list sizes!"); 4641 if (!DeclsListNum.empty()) 4642 RemainingLists = *NumListsCur; 4643 } 4644 4645 /// Construct an iterator that scan lists for a given declaration \a 4646 /// Declaration. 4647 explicit const_component_lists_iterator( 4648 const ValueDecl *Declaration, ArrayRef<ValueDecl *> UniqueDecls, 4649 ArrayRef<unsigned> DeclsListNum, ArrayRef<unsigned> CumulativeListSizes, 4650 MappableExprComponentListRef Components) 4651 : const_component_lists_iterator(UniqueDecls, DeclsListNum, 4652 CumulativeListSizes, Components) { 4653 // Look for the desired declaration. While we are looking for it, we 4654 // update the state so that we know the component where a given list 4655 // starts. 4656 for (; DeclCur != UniqueDecls.end(); ++DeclCur, ++NumListsCur) { 4657 if (*DeclCur == Declaration) 4658 break; 4659 4660 assert(*NumListsCur > 0 && "No lists associated with declaration??"); 4661 4662 // Skip the lists associated with the current declaration, but save the 4663 // last list size that was skipped. 4664 std::advance(ListSizeCur, *NumListsCur - 1); 4665 PrevListSize = *ListSizeCur; 4666 ++ListSizeCur; 4667 } 4668 4669 // If we didn't find any declaration, advance the iterator to after the 4670 // last component and set remaining lists to zero. 4671 if (ListSizeCur == CumulativeListSizes.end()) { 4672 this->I = End; 4673 RemainingLists = 0u; 4674 return; 4675 } 4676 4677 // Set the remaining lists with the total number of lists of the current 4678 // declaration. 4679 RemainingLists = *NumListsCur; 4680 4681 // Adjust the list size end iterator to the end of the relevant range. 4682 ListSizeEnd = ListSizeCur; 4683 std::advance(ListSizeEnd, RemainingLists); 4684 4685 // Given that the list sizes are cumulative, the index of the component 4686 // that start the list is the size of the previous list. 4687 std::advance(this->I, PrevListSize); 4688 } 4689 4690 // Return the array with the current list. The sizes are cumulative, so the 4691 // array size is the difference between the current size and previous one. 4692 std::pair<const ValueDecl *, MappableExprComponentListRef> 4693 operator*() const { 4694 assert(ListSizeCur != ListSizeEnd && "Invalid iterator!"); 4695 return std::make_pair( 4696 *DeclCur, 4697 MappableExprComponentListRef(&*this->I, *ListSizeCur - PrevListSize)); 4698 } 4699 std::pair<const ValueDecl *, MappableExprComponentListRef> 4700 operator->() const { 4701 return **this; 4702 } 4703 4704 // Skip the components of the current list. 4705 const_component_lists_iterator &operator++() { 4706 assert(ListSizeCur != ListSizeEnd && RemainingLists && 4707 "Invalid iterator!"); 4708 4709 // If we don't have more lists just skip all the components. Otherwise, 4710 // advance the iterator by the number of components in the current list. 4711 if (std::next(ListSizeCur) == ListSizeEnd) { 4712 this->I = End; 4713 RemainingLists = 0; 4714 } else { 4715 std::advance(this->I, *ListSizeCur - PrevListSize); 4716 PrevListSize = *ListSizeCur; 4717 4718 // We are done with a declaration, move to the next one. 4719 if (!(--RemainingLists)) { 4720 ++DeclCur; 4721 ++NumListsCur; 4722 RemainingLists = *NumListsCur; 4723 assert(RemainingLists && "No lists in the following declaration??"); 4724 } 4725 } 4726 4727 ++ListSizeCur; 4728 return *this; 4729 } 4730 }; 4731 4732 using const_component_lists_range = 4733 llvm::iterator_range<const_component_lists_iterator>; 4734 4735 /// Iterators for all component lists. 4736 const_component_lists_iterator component_lists_begin() const { 4737 return const_component_lists_iterator( 4738 getUniqueDeclsRef(), getDeclNumListsRef(), getComponentListSizesRef(), 4739 getComponentsRef()); 4740 } 4741 const_component_lists_iterator component_lists_end() const { 4742 return const_component_lists_iterator( 4743 ArrayRef<ValueDecl *>(), ArrayRef<unsigned>(), ArrayRef<unsigned>(), 4744 MappableExprComponentListRef(getComponentsRef().end(), 4745 getComponentsRef().end())); 4746 } 4747 const_component_lists_range component_lists() const { 4748 return {component_lists_begin(), component_lists_end()}; 4749 } 4750 4751 /// Iterators for component lists associated with the provided 4752 /// declaration. 4753 const_component_lists_iterator 4754 decl_component_lists_begin(const ValueDecl *VD) const { 4755 return const_component_lists_iterator( 4756 VD, getUniqueDeclsRef(), getDeclNumListsRef(), 4757 getComponentListSizesRef(), getComponentsRef()); 4758 } 4759 const_component_lists_iterator decl_component_lists_end() const { 4760 return component_lists_end(); 4761 } 4762 const_component_lists_range decl_component_lists(const ValueDecl *VD) const { 4763 return {decl_component_lists_begin(VD), decl_component_lists_end()}; 4764 } 4765 4766 /// Iterators to access all the declarations, number of lists, list sizes, and 4767 /// components. 4768 using const_all_decls_iterator = ArrayRef<ValueDecl *>::iterator; 4769 using const_all_decls_range = llvm::iterator_range<const_all_decls_iterator>; 4770 4771 const_all_decls_range all_decls() const { 4772 auto A = getUniqueDeclsRef(); 4773 return const_all_decls_range(A.begin(), A.end()); 4774 } 4775 4776 using const_all_num_lists_iterator = ArrayRef<unsigned>::iterator; 4777 using const_all_num_lists_range = 4778 llvm::iterator_range<const_all_num_lists_iterator>; 4779 4780 const_all_num_lists_range all_num_lists() const { 4781 auto A = getDeclNumListsRef(); 4782 return const_all_num_lists_range(A.begin(), A.end()); 4783 } 4784 4785 using const_all_lists_sizes_iterator = ArrayRef<unsigned>::iterator; 4786 using const_all_lists_sizes_range = 4787 llvm::iterator_range<const_all_lists_sizes_iterator>; 4788 4789 const_all_lists_sizes_range all_lists_sizes() const { 4790 auto A = getComponentListSizesRef(); 4791 return const_all_lists_sizes_range(A.begin(), A.end()); 4792 } 4793 4794 using const_all_components_iterator = ArrayRef<MappableComponent>::iterator; 4795 using const_all_components_range = 4796 llvm::iterator_range<const_all_components_iterator>; 4797 4798 const_all_components_range all_components() const { 4799 auto A = getComponentsRef(); 4800 return const_all_components_range(A.begin(), A.end()); 4801 } 4802 4803 using mapperlist_iterator = MutableArrayRef<Expr *>::iterator; 4804 using mapperlist_const_iterator = ArrayRef<const Expr *>::iterator; 4805 using mapperlist_range = llvm::iterator_range<mapperlist_iterator>; 4806 using mapperlist_const_range = 4807 llvm::iterator_range<mapperlist_const_iterator>; 4808 4809 mapperlist_iterator mapperlist_begin() { return getUDMapperRefs().begin(); } 4810 mapperlist_iterator mapperlist_end() { return getUDMapperRefs().end(); } 4811 mapperlist_const_iterator mapperlist_begin() const { 4812 return getUDMapperRefs().begin(); 4813 } 4814 mapperlist_const_iterator mapperlist_end() const { 4815 return getUDMapperRefs().end(); 4816 } 4817 mapperlist_range mapperlists() { 4818 return mapperlist_range(mapperlist_begin(), mapperlist_end()); 4819 } 4820 mapperlist_const_range mapperlists() const { 4821 return mapperlist_const_range(mapperlist_begin(), mapperlist_end()); 4822 } 4823}; 4824 4825/// This represents clause 'map' in the '#pragma omp ...' 4826/// directives. 4827/// 4828/// \code 4829/// #pragma omp target map(a,b) 4830/// \endcode 4831/// In this example directive '#pragma omp target' has clause 'map' 4832/// with the variables 'a' and 'b'. 4833class OMPMapClause final : public OMPMappableExprListClause<OMPMapClause>, 4834 private llvm::TrailingObjects< 4835 OMPMapClause, Expr *, ValueDecl *, unsigned, 4836 OMPClauseMappableExprCommon::MappableComponent> { 4837 friend class OMPClauseReader; 4838 friend OMPMappableExprListClause; 4839 friend OMPVarListClause; 4840 friend TrailingObjects; 4841 4842 /// Define the sizes of each trailing object array except the last one. This 4843 /// is required for TrailingObjects to work properly. 4844 size_t numTrailingObjects(OverloadToken<Expr *>) const { 4845 // There are varlist_size() of expressions, and varlist_size() of 4846 // user-defined mappers. 4847 return 2 * varlist_size(); 4848 } 4849 size_t numTrailingObjects(OverloadToken<ValueDecl *>) const { 4850 return getUniqueDeclarationsNum(); 4851 } 4852 size_t numTrailingObjects(OverloadToken<unsigned>) const { 4853 return getUniqueDeclarationsNum() + getTotalComponentListNum(); 4854 } 4855 4856public: 4857 /// Number of allowed map-type-modifiers. 4858 static constexpr unsigned NumberOfModifiers = 4859 OMPC_MAP_MODIFIER_last - OMPC_MAP_MODIFIER_unknown - 1; 4860 4861private: 4862 /// Map-type-modifiers for the 'map' clause. 4863 OpenMPMapModifierKind MapTypeModifiers[NumberOfModifiers] = { 4864 OMPC_MAP_MODIFIER_unknown, OMPC_MAP_MODIFIER_unknown, 4865 OMPC_MAP_MODIFIER_unknown}; 4866 4867 /// Location of map-type-modifiers for the 'map' clause. 4868 SourceLocation MapTypeModifiersLoc[NumberOfModifiers]; 4869 4870 /// Map type for the 'map' clause. 4871 OpenMPMapClauseKind MapType = OMPC_MAP_unknown; 4872 4873 /// Is this an implicit map type or not. 4874 bool MapTypeIsImplicit = false; 4875 4876 /// Location of the map type. 4877 SourceLocation MapLoc; 4878 4879 /// Colon location. 4880 SourceLocation ColonLoc; 4881 4882 /// Build a clause for \a NumVars listed expressions, \a 4883 /// NumUniqueDeclarations declarations, \a NumComponentLists total component 4884 /// lists, and \a NumComponents total expression components. 4885 /// 4886 /// \param MapModifiers Map-type-modifiers. 4887 /// \param MapModifiersLoc Locations of map-type-modifiers. 4888 /// \param MapperQualifierLoc C++ nested name specifier for the associated 4889 /// user-defined mapper. 4890 /// \param MapperIdInfo The identifier of associated user-defined mapper. 4891 /// \param MapType Map type. 4892 /// \param MapTypeIsImplicit Map type is inferred implicitly. 4893 /// \param MapLoc Location of the map type. 4894 /// \param Locs Locations needed to build a mappable clause. It includes 1) 4895 /// StartLoc: starting location of the clause (the clause keyword); 2) 4896 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 4897 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 4898 /// NumVars: number of expressions listed in this clause; 2) 4899 /// NumUniqueDeclarations: number of unique base declarations in this clause; 4900 /// 3) NumComponentLists: number of component lists in this clause; and 4) 4901 /// NumComponents: total number of expression components in the clause. 4902 explicit OMPMapClause(ArrayRef<OpenMPMapModifierKind> MapModifiers, 4903 ArrayRef<SourceLocation> MapModifiersLoc, 4904 NestedNameSpecifierLoc MapperQualifierLoc, 4905 DeclarationNameInfo MapperIdInfo, 4906 OpenMPMapClauseKind MapType, bool MapTypeIsImplicit, 4907 SourceLocation MapLoc, const OMPVarListLocTy &Locs, 4908 const OMPMappableExprListSizeTy &Sizes) 4909 : OMPMappableExprListClause(OMPC_map, Locs, Sizes, &MapperQualifierLoc, 4910 &MapperIdInfo), 4911 MapType(MapType), MapTypeIsImplicit(MapTypeIsImplicit), MapLoc(MapLoc) { 4912 assert(llvm::array_lengthof(MapTypeModifiers) == MapModifiers.size() && 4913 "Unexpected number of map type modifiers."); 4914 llvm::copy(MapModifiers, std::begin(MapTypeModifiers)); 4915 4916 assert(llvm::array_lengthof(MapTypeModifiersLoc) == 4917 MapModifiersLoc.size() && 4918 "Unexpected number of map type modifier locations."); 4919 llvm::copy(MapModifiersLoc, std::begin(MapTypeModifiersLoc)); 4920 } 4921 4922 /// Build an empty clause. 4923 /// 4924 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 4925 /// NumVars: number of expressions listed in this clause; 2) 4926 /// NumUniqueDeclarations: number of unique base declarations in this clause; 4927 /// 3) NumComponentLists: number of component lists in this clause; and 4) 4928 /// NumComponents: total number of expression components in the clause. 4929 explicit OMPMapClause(const OMPMappableExprListSizeTy &Sizes) 4930 : OMPMappableExprListClause(OMPC_map, OMPVarListLocTy(), Sizes) {} 4931 4932 /// Set map-type-modifier for the clause. 4933 /// 4934 /// \param I index for map-type-modifier. 4935 /// \param T map-type-modifier for the clause. 4936 void setMapTypeModifier(unsigned I, OpenMPMapModifierKind T) { 4937 assert(I < NumberOfModifiers && 4938 "Unexpected index to store map type modifier, exceeds array size."); 4939 MapTypeModifiers[I] = T; 4940 } 4941 4942 /// Set location for the map-type-modifier. 4943 /// 4944 /// \param I index for map-type-modifier location. 4945 /// \param TLoc map-type-modifier location. 4946 void setMapTypeModifierLoc(unsigned I, SourceLocation TLoc) { 4947 assert(I < NumberOfModifiers && 4948 "Index to store map type modifier location exceeds array size."); 4949 MapTypeModifiersLoc[I] = TLoc; 4950 } 4951 4952 /// Set type for the clause. 4953 /// 4954 /// \param T Type for the clause. 4955 void setMapType(OpenMPMapClauseKind T) { MapType = T; } 4956 4957 /// Set type location. 4958 /// 4959 /// \param TLoc Type location. 4960 void setMapLoc(SourceLocation TLoc) { MapLoc = TLoc; } 4961 4962 /// Set colon location. 4963 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } 4964 4965public: 4966 /// Creates clause with a list of variables \a VL. 4967 /// 4968 /// \param C AST context. 4969 /// \param Locs Locations needed to build a mappable clause. It includes 1) 4970 /// StartLoc: starting location of the clause (the clause keyword); 2) 4971 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 4972 /// \param Vars The original expression used in the clause. 4973 /// \param Declarations Declarations used in the clause. 4974 /// \param ComponentLists Component lists used in the clause. 4975 /// \param UDMapperRefs References to user-defined mappers associated with 4976 /// expressions used in the clause. 4977 /// \param MapModifiers Map-type-modifiers. 4978 /// \param MapModifiersLoc Location of map-type-modifiers. 4979 /// \param UDMQualifierLoc C++ nested name specifier for the associated 4980 /// user-defined mapper. 4981 /// \param MapperId The identifier of associated user-defined mapper. 4982 /// \param Type Map type. 4983 /// \param TypeIsImplicit Map type is inferred implicitly. 4984 /// \param TypeLoc Location of the map type. 4985 static OMPMapClause * 4986 Create(const ASTContext &C, const OMPVarListLocTy &Locs, 4987 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations, 4988 MappableExprComponentListsRef ComponentLists, 4989 ArrayRef<Expr *> UDMapperRefs, 4990 ArrayRef<OpenMPMapModifierKind> MapModifiers, 4991 ArrayRef<SourceLocation> MapModifiersLoc, 4992 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId, 4993 OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc); 4994 4995 /// Creates an empty clause with the place for \a NumVars original 4996 /// expressions, \a NumUniqueDeclarations declarations, \NumComponentLists 4997 /// lists, and \a NumComponents expression components. 4998 /// 4999 /// \param C AST context. 5000 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5001 /// NumVars: number of expressions listed in this clause; 2) 5002 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5003 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5004 /// NumComponents: total number of expression components in the clause. 5005 static OMPMapClause *CreateEmpty(const ASTContext &C, 5006 const OMPMappableExprListSizeTy &Sizes); 5007 5008 /// Fetches mapping kind for the clause. 5009 OpenMPMapClauseKind getMapType() const LLVM_READONLY { return MapType; } 5010 5011 /// Is this an implicit map type? 5012 /// We have to capture 'IsMapTypeImplicit' from the parser for more 5013 /// informative error messages. It helps distinguish map(r) from 5014 /// map(tofrom: r), which is important to print more helpful error 5015 /// messages for some target directives. 5016 bool isImplicitMapType() const LLVM_READONLY { return MapTypeIsImplicit; } 5017 5018 /// Fetches the map-type-modifier at 'Cnt' index of array of modifiers. 5019 /// 5020 /// \param Cnt index for map-type-modifier. 5021 OpenMPMapModifierKind getMapTypeModifier(unsigned Cnt) const LLVM_READONLY { 5022 assert(Cnt < NumberOfModifiers && 5023 "Requested modifier exceeds the total number of modifiers."); 5024 return MapTypeModifiers[Cnt]; 5025 } 5026 5027 /// Fetches the map-type-modifier location at 'Cnt' index of array of 5028 /// modifiers' locations. 5029 /// 5030 /// \param Cnt index for map-type-modifier location. 5031 SourceLocation getMapTypeModifierLoc(unsigned Cnt) const LLVM_READONLY { 5032 assert(Cnt < NumberOfModifiers && 5033 "Requested modifier location exceeds total number of modifiers."); 5034 return MapTypeModifiersLoc[Cnt]; 5035 } 5036 5037 /// Fetches ArrayRef of map-type-modifiers. 5038 ArrayRef<OpenMPMapModifierKind> getMapTypeModifiers() const LLVM_READONLY { 5039 return llvm::makeArrayRef(MapTypeModifiers); 5040 } 5041 5042 /// Fetches ArrayRef of location of map-type-modifiers. 5043 ArrayRef<SourceLocation> getMapTypeModifiersLoc() const LLVM_READONLY { 5044 return llvm::makeArrayRef(MapTypeModifiersLoc); 5045 } 5046 5047 /// Fetches location of clause mapping kind. 5048 SourceLocation getMapLoc() const LLVM_READONLY { return MapLoc; } 5049 5050 /// Get colon location. 5051 SourceLocation getColonLoc() const { return ColonLoc; } 5052 5053 child_range children() { 5054 return child_range( 5055 reinterpret_cast<Stmt **>(varlist_begin()), 5056 reinterpret_cast<Stmt **>(varlist_end())); 5057 } 5058 5059 const_child_range children() const { 5060 auto Children = const_cast<OMPMapClause *>(this)->children(); 5061 return const_child_range(Children.begin(), Children.end()); 5062 } 5063 5064 child_range used_children() { 5065 if (MapType == OMPC_MAP_to || MapType == OMPC_MAP_tofrom) 5066 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 5067 reinterpret_cast<Stmt **>(varlist_end())); 5068 return child_range(child_iterator(), child_iterator()); 5069 } 5070 const_child_range used_children() const { 5071 auto Children = const_cast<OMPMapClause *>(this)->used_children(); 5072 return const_child_range(Children.begin(), Children.end()); 5073 } 5074 5075 5076 static bool classof(const OMPClause *T) { 5077 return T->getClauseKind() == OMPC_map; 5078 } 5079}; 5080 5081/// This represents 'num_teams' clause in the '#pragma omp ...' 5082/// directive. 5083/// 5084/// \code 5085/// #pragma omp teams num_teams(n) 5086/// \endcode 5087/// In this example directive '#pragma omp teams' has clause 'num_teams' 5088/// with single expression 'n'. 5089class OMPNumTeamsClause : public OMPClause, public OMPClauseWithPreInit { 5090 friend class OMPClauseReader; 5091 5092 /// Location of '('. 5093 SourceLocation LParenLoc; 5094 5095 /// NumTeams number. 5096 Stmt *NumTeams = nullptr; 5097 5098 /// Set the NumTeams number. 5099 /// 5100 /// \param E NumTeams number. 5101 void setNumTeams(Expr *E) { NumTeams = E; } 5102 5103public: 5104 /// Build 'num_teams' clause. 5105 /// 5106 /// \param E Expression associated with this clause. 5107 /// \param HelperE Helper Expression associated with this clause. 5108 /// \param CaptureRegion Innermost OpenMP region where expressions in this 5109 /// clause must be captured. 5110 /// \param StartLoc Starting location of the clause. 5111 /// \param LParenLoc Location of '('. 5112 /// \param EndLoc Ending location of the clause. 5113 OMPNumTeamsClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion, 5114 SourceLocation StartLoc, SourceLocation LParenLoc, 5115 SourceLocation EndLoc) 5116 : OMPClause(OMPC_num_teams, StartLoc, EndLoc), OMPClauseWithPreInit(this), 5117 LParenLoc(LParenLoc), NumTeams(E) { 5118 setPreInitStmt(HelperE, CaptureRegion); 5119 } 5120 5121 /// Build an empty clause. 5122 OMPNumTeamsClause() 5123 : OMPClause(OMPC_num_teams, SourceLocation(), SourceLocation()), 5124 OMPClauseWithPreInit(this) {} 5125 5126 /// Sets the location of '('. 5127 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5128 5129 /// Returns the location of '('. 5130 SourceLocation getLParenLoc() const { return LParenLoc; } 5131 5132 /// Return NumTeams number. 5133 Expr *getNumTeams() { return cast<Expr>(NumTeams); } 5134 5135 /// Return NumTeams number. 5136 Expr *getNumTeams() const { return cast<Expr>(NumTeams); } 5137 5138 child_range children() { return child_range(&NumTeams, &NumTeams + 1); } 5139 5140 const_child_range children() const { 5141 return const_child_range(&NumTeams, &NumTeams + 1); 5142 } 5143 5144 child_range used_children() { 5145 return child_range(child_iterator(), child_iterator()); 5146 } 5147 const_child_range used_children() const { 5148 return const_child_range(const_child_iterator(), const_child_iterator()); 5149 } 5150 5151 static bool classof(const OMPClause *T) { 5152 return T->getClauseKind() == OMPC_num_teams; 5153 } 5154}; 5155 5156/// This represents 'thread_limit' clause in the '#pragma omp ...' 5157/// directive. 5158/// 5159/// \code 5160/// #pragma omp teams thread_limit(n) 5161/// \endcode 5162/// In this example directive '#pragma omp teams' has clause 'thread_limit' 5163/// with single expression 'n'. 5164class OMPThreadLimitClause : public OMPClause, public OMPClauseWithPreInit { 5165 friend class OMPClauseReader; 5166 5167 /// Location of '('. 5168 SourceLocation LParenLoc; 5169 5170 /// ThreadLimit number. 5171 Stmt *ThreadLimit = nullptr; 5172 5173 /// Set the ThreadLimit number. 5174 /// 5175 /// \param E ThreadLimit number. 5176 void setThreadLimit(Expr *E) { ThreadLimit = E; } 5177 5178public: 5179 /// Build 'thread_limit' clause. 5180 /// 5181 /// \param E Expression associated with this clause. 5182 /// \param HelperE Helper Expression associated with this clause. 5183 /// \param CaptureRegion Innermost OpenMP region where expressions in this 5184 /// clause must be captured. 5185 /// \param StartLoc Starting location of the clause. 5186 /// \param LParenLoc Location of '('. 5187 /// \param EndLoc Ending location of the clause. 5188 OMPThreadLimitClause(Expr *E, Stmt *HelperE, 5189 OpenMPDirectiveKind CaptureRegion, 5190 SourceLocation StartLoc, SourceLocation LParenLoc, 5191 SourceLocation EndLoc) 5192 : OMPClause(OMPC_thread_limit, StartLoc, EndLoc), 5193 OMPClauseWithPreInit(this), LParenLoc(LParenLoc), ThreadLimit(E) { 5194 setPreInitStmt(HelperE, CaptureRegion); 5195 } 5196 5197 /// Build an empty clause. 5198 OMPThreadLimitClause() 5199 : OMPClause(OMPC_thread_limit, SourceLocation(), SourceLocation()), 5200 OMPClauseWithPreInit(this) {} 5201 5202 /// Sets the location of '('. 5203 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5204 5205 /// Returns the location of '('. 5206 SourceLocation getLParenLoc() const { return LParenLoc; } 5207 5208 /// Return ThreadLimit number. 5209 Expr *getThreadLimit() { return cast<Expr>(ThreadLimit); } 5210 5211 /// Return ThreadLimit number. 5212 Expr *getThreadLimit() const { return cast<Expr>(ThreadLimit); } 5213 5214 child_range children() { return child_range(&ThreadLimit, &ThreadLimit + 1); } 5215 5216 const_child_range children() const { 5217 return const_child_range(&ThreadLimit, &ThreadLimit + 1); 5218 } 5219 5220 child_range used_children() { 5221 return child_range(child_iterator(), child_iterator()); 5222 } 5223 const_child_range used_children() const { 5224 return const_child_range(const_child_iterator(), const_child_iterator()); 5225 } 5226 5227 static bool classof(const OMPClause *T) { 5228 return T->getClauseKind() == OMPC_thread_limit; 5229 } 5230}; 5231 5232/// This represents 'priority' clause in the '#pragma omp ...' 5233/// directive. 5234/// 5235/// \code 5236/// #pragma omp task priority(n) 5237/// \endcode 5238/// In this example directive '#pragma omp teams' has clause 'priority' with 5239/// single expression 'n'. 5240class OMPPriorityClause : public OMPClause, public OMPClauseWithPreInit { 5241 friend class OMPClauseReader; 5242 5243 /// Location of '('. 5244 SourceLocation LParenLoc; 5245 5246 /// Priority number. 5247 Stmt *Priority = nullptr; 5248 5249 /// Set the Priority number. 5250 /// 5251 /// \param E Priority number. 5252 void setPriority(Expr *E) { Priority = E; } 5253 5254public: 5255 /// Build 'priority' clause. 5256 /// 5257 /// \param Priority Expression associated with this clause. 5258 /// \param HelperPriority Helper priority for the construct. 5259 /// \param CaptureRegion Innermost OpenMP region where expressions in this 5260 /// clause must be captured. 5261 /// \param StartLoc Starting location of the clause. 5262 /// \param LParenLoc Location of '('. 5263 /// \param EndLoc Ending location of the clause. 5264 OMPPriorityClause(Expr *Priority, Stmt *HelperPriority, 5265 OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, 5266 SourceLocation LParenLoc, SourceLocation EndLoc) 5267 : OMPClause(OMPC_priority, StartLoc, EndLoc), OMPClauseWithPreInit(this), 5268 LParenLoc(LParenLoc), Priority(Priority) { 5269 setPreInitStmt(HelperPriority, CaptureRegion); 5270 } 5271 5272 /// Build an empty clause. 5273 OMPPriorityClause() 5274 : OMPClause(OMPC_priority, SourceLocation(), SourceLocation()), 5275 OMPClauseWithPreInit(this) {} 5276 5277 /// Sets the location of '('. 5278 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5279 5280 /// Returns the location of '('. 5281 SourceLocation getLParenLoc() const { return LParenLoc; } 5282 5283 /// Return Priority number. 5284 Expr *getPriority() { return cast<Expr>(Priority); } 5285 5286 /// Return Priority number. 5287 Expr *getPriority() const { return cast<Expr>(Priority); } 5288 5289 child_range children() { return child_range(&Priority, &Priority + 1); } 5290 5291 const_child_range children() const { 5292 return const_child_range(&Priority, &Priority + 1); 5293 } 5294 5295 child_range used_children(); 5296 const_child_range used_children() const { 5297 auto Children = const_cast<OMPPriorityClause *>(this)->used_children(); 5298 return const_child_range(Children.begin(), Children.end()); 5299 } 5300 5301 static bool classof(const OMPClause *T) { 5302 return T->getClauseKind() == OMPC_priority; 5303 } 5304}; 5305 5306/// This represents 'grainsize' clause in the '#pragma omp ...' 5307/// directive. 5308/// 5309/// \code 5310/// #pragma omp taskloop grainsize(4) 5311/// \endcode 5312/// In this example directive '#pragma omp taskloop' has clause 'grainsize' 5313/// with single expression '4'. 5314class OMPGrainsizeClause : public OMPClause, public OMPClauseWithPreInit { 5315 friend class OMPClauseReader; 5316 5317 /// Location of '('. 5318 SourceLocation LParenLoc; 5319 5320 /// Safe iteration space distance. 5321 Stmt *Grainsize = nullptr; 5322 5323 /// Set safelen. 5324 void setGrainsize(Expr *Size) { Grainsize = Size; } 5325 5326public: 5327 /// Build 'grainsize' clause. 5328 /// 5329 /// \param Size Expression associated with this clause. 5330 /// \param HelperSize Helper grainsize for the construct. 5331 /// \param CaptureRegion Innermost OpenMP region where expressions in this 5332 /// clause must be captured. 5333 /// \param StartLoc Starting location of the clause. 5334 /// \param EndLoc Ending location of the clause. 5335 OMPGrainsizeClause(Expr *Size, Stmt *HelperSize, 5336 OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, 5337 SourceLocation LParenLoc, SourceLocation EndLoc) 5338 : OMPClause(OMPC_grainsize, StartLoc, EndLoc), OMPClauseWithPreInit(this), 5339 LParenLoc(LParenLoc), Grainsize(Size) { 5340 setPreInitStmt(HelperSize, CaptureRegion); 5341 } 5342 5343 /// Build an empty clause. 5344 explicit OMPGrainsizeClause() 5345 : OMPClause(OMPC_grainsize, SourceLocation(), SourceLocation()), 5346 OMPClauseWithPreInit(this) {} 5347 5348 /// Sets the location of '('. 5349 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5350 5351 /// Returns the location of '('. 5352 SourceLocation getLParenLoc() const { return LParenLoc; } 5353 5354 /// Return safe iteration space distance. 5355 Expr *getGrainsize() const { return cast_or_null<Expr>(Grainsize); } 5356 5357 child_range children() { return child_range(&Grainsize, &Grainsize + 1); } 5358 5359 const_child_range children() const { 5360 return const_child_range(&Grainsize, &Grainsize + 1); 5361 } 5362 5363 child_range used_children(); 5364 const_child_range used_children() const { 5365 auto Children = const_cast<OMPGrainsizeClause *>(this)->used_children(); 5366 return const_child_range(Children.begin(), Children.end()); 5367 } 5368 5369 static bool classof(const OMPClause *T) { 5370 return T->getClauseKind() == OMPC_grainsize; 5371 } 5372}; 5373 5374/// This represents 'nogroup' clause in the '#pragma omp ...' directive. 5375/// 5376/// \code 5377/// #pragma omp taskloop nogroup 5378/// \endcode 5379/// In this example directive '#pragma omp taskloop' has 'nogroup' clause. 5380class OMPNogroupClause : public OMPClause { 5381public: 5382 /// Build 'nogroup' clause. 5383 /// 5384 /// \param StartLoc Starting location of the clause. 5385 /// \param EndLoc Ending location of the clause. 5386 OMPNogroupClause(SourceLocation StartLoc, SourceLocation EndLoc) 5387 : OMPClause(OMPC_nogroup, StartLoc, EndLoc) {} 5388 5389 /// Build an empty clause. 5390 OMPNogroupClause() 5391 : OMPClause(OMPC_nogroup, SourceLocation(), SourceLocation()) {} 5392 5393 child_range children() { 5394 return child_range(child_iterator(), child_iterator()); 5395 } 5396 5397 const_child_range children() const { 5398 return const_child_range(const_child_iterator(), const_child_iterator()); 5399 } 5400 5401 child_range used_children() { 5402 return child_range(child_iterator(), child_iterator()); 5403 } 5404 const_child_range used_children() const { 5405 return const_child_range(const_child_iterator(), const_child_iterator()); 5406 } 5407 5408 static bool classof(const OMPClause *T) { 5409 return T->getClauseKind() == OMPC_nogroup; 5410 } 5411}; 5412 5413/// This represents 'num_tasks' clause in the '#pragma omp ...' 5414/// directive. 5415/// 5416/// \code 5417/// #pragma omp taskloop num_tasks(4) 5418/// \endcode 5419/// In this example directive '#pragma omp taskloop' has clause 'num_tasks' 5420/// with single expression '4'. 5421class OMPNumTasksClause : public OMPClause, public OMPClauseWithPreInit { 5422 friend class OMPClauseReader; 5423 5424 /// Location of '('. 5425 SourceLocation LParenLoc; 5426 5427 /// Safe iteration space distance. 5428 Stmt *NumTasks = nullptr; 5429 5430 /// Set safelen. 5431 void setNumTasks(Expr *Size) { NumTasks = Size; } 5432 5433public: 5434 /// Build 'num_tasks' clause. 5435 /// 5436 /// \param Size Expression associated with this clause. 5437 /// \param HelperSize Helper grainsize for the construct. 5438 /// \param CaptureRegion Innermost OpenMP region where expressions in this 5439 /// clause must be captured. 5440 /// \param StartLoc Starting location of the clause. 5441 /// \param EndLoc Ending location of the clause. 5442 OMPNumTasksClause(Expr *Size, Stmt *HelperSize, 5443 OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, 5444 SourceLocation LParenLoc, SourceLocation EndLoc) 5445 : OMPClause(OMPC_num_tasks, StartLoc, EndLoc), OMPClauseWithPreInit(this), 5446 LParenLoc(LParenLoc), NumTasks(Size) { 5447 setPreInitStmt(HelperSize, CaptureRegion); 5448 } 5449 5450 /// Build an empty clause. 5451 explicit OMPNumTasksClause() 5452 : OMPClause(OMPC_num_tasks, SourceLocation(), SourceLocation()), 5453 OMPClauseWithPreInit(this) {} 5454 5455 /// Sets the location of '('. 5456 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5457 5458 /// Returns the location of '('. 5459 SourceLocation getLParenLoc() const { return LParenLoc; } 5460 5461 /// Return safe iteration space distance. 5462 Expr *getNumTasks() const { return cast_or_null<Expr>(NumTasks); } 5463 5464 child_range children() { return child_range(&NumTasks, &NumTasks + 1); } 5465 5466 const_child_range children() const { 5467 return const_child_range(&NumTasks, &NumTasks + 1); 5468 } 5469 5470 child_range used_children(); 5471 const_child_range used_children() const { 5472 auto Children = const_cast<OMPNumTasksClause *>(this)->used_children(); 5473 return const_child_range(Children.begin(), Children.end()); 5474 } 5475 5476 static bool classof(const OMPClause *T) { 5477 return T->getClauseKind() == OMPC_num_tasks; 5478 } 5479}; 5480 5481/// This represents 'hint' clause in the '#pragma omp ...' directive. 5482/// 5483/// \code 5484/// #pragma omp critical (name) hint(6) 5485/// \endcode 5486/// In this example directive '#pragma omp critical' has name 'name' and clause 5487/// 'hint' with argument '6'. 5488class OMPHintClause : public OMPClause { 5489 friend class OMPClauseReader; 5490 5491 /// Location of '('. 5492 SourceLocation LParenLoc; 5493 5494 /// Hint expression of the 'hint' clause. 5495 Stmt *Hint = nullptr; 5496 5497 /// Set hint expression. 5498 void setHint(Expr *H) { Hint = H; } 5499 5500public: 5501 /// Build 'hint' clause with expression \a Hint. 5502 /// 5503 /// \param Hint Hint expression. 5504 /// \param StartLoc Starting location of the clause. 5505 /// \param LParenLoc Location of '('. 5506 /// \param EndLoc Ending location of the clause. 5507 OMPHintClause(Expr *Hint, SourceLocation StartLoc, SourceLocation LParenLoc, 5508 SourceLocation EndLoc) 5509 : OMPClause(OMPC_hint, StartLoc, EndLoc), LParenLoc(LParenLoc), 5510 Hint(Hint) {} 5511 5512 /// Build an empty clause. 5513 OMPHintClause() : OMPClause(OMPC_hint, SourceLocation(), SourceLocation()) {} 5514 5515 /// Sets the location of '('. 5516 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5517 5518 /// Returns the location of '('. 5519 SourceLocation getLParenLoc() const { return LParenLoc; } 5520 5521 /// Returns number of threads. 5522 Expr *getHint() const { return cast_or_null<Expr>(Hint); } 5523 5524 child_range children() { return child_range(&Hint, &Hint + 1); } 5525 5526 const_child_range children() const { 5527 return const_child_range(&Hint, &Hint + 1); 5528 } 5529 5530 child_range used_children() { 5531 return child_range(child_iterator(), child_iterator()); 5532 } 5533 const_child_range used_children() const { 5534 return const_child_range(const_child_iterator(), const_child_iterator()); 5535 } 5536 5537 static bool classof(const OMPClause *T) { 5538 return T->getClauseKind() == OMPC_hint; 5539 } 5540}; 5541 5542/// This represents 'dist_schedule' clause in the '#pragma omp ...' 5543/// directive. 5544/// 5545/// \code 5546/// #pragma omp distribute dist_schedule(static, 3) 5547/// \endcode 5548/// In this example directive '#pragma omp distribute' has 'dist_schedule' 5549/// clause with arguments 'static' and '3'. 5550class OMPDistScheduleClause : public OMPClause, public OMPClauseWithPreInit { 5551 friend class OMPClauseReader; 5552 5553 /// Location of '('. 5554 SourceLocation LParenLoc; 5555 5556 /// A kind of the 'schedule' clause. 5557 OpenMPDistScheduleClauseKind Kind = OMPC_DIST_SCHEDULE_unknown; 5558 5559 /// Start location of the schedule kind in source code. 5560 SourceLocation KindLoc; 5561 5562 /// Location of ',' (if any). 5563 SourceLocation CommaLoc; 5564 5565 /// Chunk size. 5566 Expr *ChunkSize = nullptr; 5567 5568 /// Set schedule kind. 5569 /// 5570 /// \param K Schedule kind. 5571 void setDistScheduleKind(OpenMPDistScheduleClauseKind K) { Kind = K; } 5572 5573 /// Sets the location of '('. 5574 /// 5575 /// \param Loc Location of '('. 5576 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5577 5578 /// Set schedule kind start location. 5579 /// 5580 /// \param KLoc Schedule kind location. 5581 void setDistScheduleKindLoc(SourceLocation KLoc) { KindLoc = KLoc; } 5582 5583 /// Set location of ','. 5584 /// 5585 /// \param Loc Location of ','. 5586 void setCommaLoc(SourceLocation Loc) { CommaLoc = Loc; } 5587 5588 /// Set chunk size. 5589 /// 5590 /// \param E Chunk size. 5591 void setChunkSize(Expr *E) { ChunkSize = E; } 5592 5593public: 5594 /// Build 'dist_schedule' clause with schedule kind \a Kind and chunk 5595 /// size expression \a ChunkSize. 5596 /// 5597 /// \param StartLoc Starting location of the clause. 5598 /// \param LParenLoc Location of '('. 5599 /// \param KLoc Starting location of the argument. 5600 /// \param CommaLoc Location of ','. 5601 /// \param EndLoc Ending location of the clause. 5602 /// \param Kind DistSchedule kind. 5603 /// \param ChunkSize Chunk size. 5604 /// \param HelperChunkSize Helper chunk size for combined directives. 5605 OMPDistScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc, 5606 SourceLocation KLoc, SourceLocation CommaLoc, 5607 SourceLocation EndLoc, 5608 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, 5609 Stmt *HelperChunkSize) 5610 : OMPClause(OMPC_dist_schedule, StartLoc, EndLoc), 5611 OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Kind(Kind), 5612 KindLoc(KLoc), CommaLoc(CommaLoc), ChunkSize(ChunkSize) { 5613 setPreInitStmt(HelperChunkSize); 5614 } 5615 5616 /// Build an empty clause. 5617 explicit OMPDistScheduleClause() 5618 : OMPClause(OMPC_dist_schedule, SourceLocation(), SourceLocation()), 5619 OMPClauseWithPreInit(this) {} 5620 5621 /// Get kind of the clause. 5622 OpenMPDistScheduleClauseKind getDistScheduleKind() const { return Kind; } 5623 5624 /// Get location of '('. 5625 SourceLocation getLParenLoc() { return LParenLoc; } 5626 5627 /// Get kind location. 5628 SourceLocation getDistScheduleKindLoc() { return KindLoc; } 5629 5630 /// Get location of ','. 5631 SourceLocation getCommaLoc() { return CommaLoc; } 5632 5633 /// Get chunk size. 5634 Expr *getChunkSize() { return ChunkSize; } 5635 5636 /// Get chunk size. 5637 const Expr *getChunkSize() const { return ChunkSize; } 5638 5639 child_range children() { 5640 return child_range(reinterpret_cast<Stmt **>(&ChunkSize), 5641 reinterpret_cast<Stmt **>(&ChunkSize) + 1); 5642 } 5643 5644 const_child_range children() const { 5645 auto Children = const_cast<OMPDistScheduleClause *>(this)->children(); 5646 return const_child_range(Children.begin(), Children.end()); 5647 } 5648 5649 child_range used_children() { 5650 return child_range(child_iterator(), child_iterator()); 5651 } 5652 const_child_range used_children() const { 5653 return const_child_range(const_child_iterator(), const_child_iterator()); 5654 } 5655 5656 static bool classof(const OMPClause *T) { 5657 return T->getClauseKind() == OMPC_dist_schedule; 5658 } 5659}; 5660 5661/// This represents 'defaultmap' clause in the '#pragma omp ...' directive. 5662/// 5663/// \code 5664/// #pragma omp target defaultmap(tofrom: scalar) 5665/// \endcode 5666/// In this example directive '#pragma omp target' has 'defaultmap' clause of kind 5667/// 'scalar' with modifier 'tofrom'. 5668class OMPDefaultmapClause : public OMPClause { 5669 friend class OMPClauseReader; 5670 5671 /// Location of '('. 5672 SourceLocation LParenLoc; 5673 5674 /// Modifiers for 'defaultmap' clause. 5675 OpenMPDefaultmapClauseModifier Modifier = OMPC_DEFAULTMAP_MODIFIER_unknown; 5676 5677 /// Locations of modifiers. 5678 SourceLocation ModifierLoc; 5679 5680 /// A kind of the 'defaultmap' clause. 5681 OpenMPDefaultmapClauseKind Kind = OMPC_DEFAULTMAP_unknown; 5682 5683 /// Start location of the defaultmap kind in source code. 5684 SourceLocation KindLoc; 5685 5686 /// Set defaultmap kind. 5687 /// 5688 /// \param K Defaultmap kind. 5689 void setDefaultmapKind(OpenMPDefaultmapClauseKind K) { Kind = K; } 5690 5691 /// Set the defaultmap modifier. 5692 /// 5693 /// \param M Defaultmap modifier. 5694 void setDefaultmapModifier(OpenMPDefaultmapClauseModifier M) { 5695 Modifier = M; 5696 } 5697 5698 /// Set location of the defaultmap modifier. 5699 void setDefaultmapModifierLoc(SourceLocation Loc) { 5700 ModifierLoc = Loc; 5701 } 5702 5703 /// Sets the location of '('. 5704 /// 5705 /// \param Loc Location of '('. 5706 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; } 5707 5708 /// Set defaultmap kind start location. 5709 /// 5710 /// \param KLoc Defaultmap kind location. 5711 void setDefaultmapKindLoc(SourceLocation KLoc) { KindLoc = KLoc; } 5712 5713public: 5714 /// Build 'defaultmap' clause with defaultmap kind \a Kind 5715 /// 5716 /// \param StartLoc Starting location of the clause. 5717 /// \param LParenLoc Location of '('. 5718 /// \param KLoc Starting location of the argument. 5719 /// \param EndLoc Ending location of the clause. 5720 /// \param Kind Defaultmap kind. 5721 /// \param M The modifier applied to 'defaultmap' clause. 5722 /// \param MLoc Location of the modifier 5723 OMPDefaultmapClause(SourceLocation StartLoc, SourceLocation LParenLoc, 5724 SourceLocation MLoc, SourceLocation KLoc, 5725 SourceLocation EndLoc, OpenMPDefaultmapClauseKind Kind, 5726 OpenMPDefaultmapClauseModifier M) 5727 : OMPClause(OMPC_defaultmap, StartLoc, EndLoc), LParenLoc(LParenLoc), 5728 Modifier(M), ModifierLoc(MLoc), Kind(Kind), KindLoc(KLoc) {} 5729 5730 /// Build an empty clause. 5731 explicit OMPDefaultmapClause() 5732 : OMPClause(OMPC_defaultmap, SourceLocation(), SourceLocation()) {} 5733 5734 /// Get kind of the clause. 5735 OpenMPDefaultmapClauseKind getDefaultmapKind() const { return Kind; } 5736 5737 /// Get the modifier of the clause. 5738 OpenMPDefaultmapClauseModifier getDefaultmapModifier() const { 5739 return Modifier; 5740 } 5741 5742 /// Get location of '('. 5743 SourceLocation getLParenLoc() { return LParenLoc; } 5744 5745 /// Get kind location. 5746 SourceLocation getDefaultmapKindLoc() { return KindLoc; } 5747 5748 /// Get the modifier location. 5749 SourceLocation getDefaultmapModifierLoc() const { 5750 return ModifierLoc; 5751 } 5752 5753 child_range children() { 5754 return child_range(child_iterator(), child_iterator()); 5755 } 5756 5757 const_child_range children() const { 5758 return const_child_range(const_child_iterator(), const_child_iterator()); 5759 } 5760 5761 child_range used_children() { 5762 return child_range(child_iterator(), child_iterator()); 5763 } 5764 const_child_range used_children() const { 5765 return const_child_range(const_child_iterator(), const_child_iterator()); 5766 } 5767 5768 static bool classof(const OMPClause *T) { 5769 return T->getClauseKind() == OMPC_defaultmap; 5770 } 5771}; 5772 5773/// This represents clause 'to' in the '#pragma omp ...' 5774/// directives. 5775/// 5776/// \code 5777/// #pragma omp target update to(a,b) 5778/// \endcode 5779/// In this example directive '#pragma omp target update' has clause 'to' 5780/// with the variables 'a' and 'b'. 5781class OMPToClause final : public OMPMappableExprListClause<OMPToClause>, 5782 private llvm::TrailingObjects< 5783 OMPToClause, Expr *, ValueDecl *, unsigned, 5784 OMPClauseMappableExprCommon::MappableComponent> { 5785 friend class OMPClauseReader; 5786 friend OMPMappableExprListClause; 5787 friend OMPVarListClause; 5788 friend TrailingObjects; 5789 5790 /// Build clause with number of variables \a NumVars. 5791 /// 5792 /// \param MapperQualifierLoc C++ nested name specifier for the associated 5793 /// user-defined mapper. 5794 /// \param MapperIdInfo The identifier of associated user-defined mapper. 5795 /// \param Locs Locations needed to build a mappable clause. It includes 1) 5796 /// StartLoc: starting location of the clause (the clause keyword); 2) 5797 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 5798 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5799 /// NumVars: number of expressions listed in this clause; 2) 5800 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5801 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5802 /// NumComponents: total number of expression components in the clause. 5803 explicit OMPToClause(NestedNameSpecifierLoc MapperQualifierLoc, 5804 DeclarationNameInfo MapperIdInfo, 5805 const OMPVarListLocTy &Locs, 5806 const OMPMappableExprListSizeTy &Sizes) 5807 : OMPMappableExprListClause(OMPC_to, Locs, Sizes, &MapperQualifierLoc, 5808 &MapperIdInfo) {} 5809 5810 /// Build an empty clause. 5811 /// 5812 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5813 /// NumVars: number of expressions listed in this clause; 2) 5814 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5815 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5816 /// NumComponents: total number of expression components in the clause. 5817 explicit OMPToClause(const OMPMappableExprListSizeTy &Sizes) 5818 : OMPMappableExprListClause(OMPC_to, OMPVarListLocTy(), Sizes) {} 5819 5820 /// Define the sizes of each trailing object array except the last one. This 5821 /// is required for TrailingObjects to work properly. 5822 size_t numTrailingObjects(OverloadToken<Expr *>) const { 5823 // There are varlist_size() of expressions, and varlist_size() of 5824 // user-defined mappers. 5825 return 2 * varlist_size(); 5826 } 5827 size_t numTrailingObjects(OverloadToken<ValueDecl *>) const { 5828 return getUniqueDeclarationsNum(); 5829 } 5830 size_t numTrailingObjects(OverloadToken<unsigned>) const { 5831 return getUniqueDeclarationsNum() + getTotalComponentListNum(); 5832 } 5833 5834public: 5835 /// Creates clause with a list of variables \a Vars. 5836 /// 5837 /// \param C AST context. 5838 /// \param Locs Locations needed to build a mappable clause. It includes 1) 5839 /// StartLoc: starting location of the clause (the clause keyword); 2) 5840 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 5841 /// \param Vars The original expression used in the clause. 5842 /// \param Declarations Declarations used in the clause. 5843 /// \param ComponentLists Component lists used in the clause. 5844 /// \param UDMapperRefs References to user-defined mappers associated with 5845 /// expressions used in the clause. 5846 /// \param UDMQualifierLoc C++ nested name specifier for the associated 5847 /// user-defined mapper. 5848 /// \param MapperId The identifier of associated user-defined mapper. 5849 static OMPToClause *Create(const ASTContext &C, const OMPVarListLocTy &Locs, 5850 ArrayRef<Expr *> Vars, 5851 ArrayRef<ValueDecl *> Declarations, 5852 MappableExprComponentListsRef ComponentLists, 5853 ArrayRef<Expr *> UDMapperRefs, 5854 NestedNameSpecifierLoc UDMQualifierLoc, 5855 DeclarationNameInfo MapperId); 5856 5857 /// Creates an empty clause with the place for \a NumVars variables. 5858 /// 5859 /// \param C AST context. 5860 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5861 /// NumVars: number of expressions listed in this clause; 2) 5862 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5863 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5864 /// NumComponents: total number of expression components in the clause. 5865 static OMPToClause *CreateEmpty(const ASTContext &C, 5866 const OMPMappableExprListSizeTy &Sizes); 5867 5868 child_range children() { 5869 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 5870 reinterpret_cast<Stmt **>(varlist_end())); 5871 } 5872 5873 const_child_range children() const { 5874 auto Children = const_cast<OMPToClause *>(this)->children(); 5875 return const_child_range(Children.begin(), Children.end()); 5876 } 5877 5878 child_range used_children() { 5879 return child_range(child_iterator(), child_iterator()); 5880 } 5881 const_child_range used_children() const { 5882 return const_child_range(const_child_iterator(), const_child_iterator()); 5883 } 5884 5885 static bool classof(const OMPClause *T) { 5886 return T->getClauseKind() == OMPC_to; 5887 } 5888}; 5889 5890/// This represents clause 'from' in the '#pragma omp ...' 5891/// directives. 5892/// 5893/// \code 5894/// #pragma omp target update from(a,b) 5895/// \endcode 5896/// In this example directive '#pragma omp target update' has clause 'from' 5897/// with the variables 'a' and 'b'. 5898class OMPFromClause final 5899 : public OMPMappableExprListClause<OMPFromClause>, 5900 private llvm::TrailingObjects< 5901 OMPFromClause, Expr *, ValueDecl *, unsigned, 5902 OMPClauseMappableExprCommon::MappableComponent> { 5903 friend class OMPClauseReader; 5904 friend OMPMappableExprListClause; 5905 friend OMPVarListClause; 5906 friend TrailingObjects; 5907 5908 /// Build clause with number of variables \a NumVars. 5909 /// 5910 /// \param MapperQualifierLoc C++ nested name specifier for the associated 5911 /// user-defined mapper. 5912 /// \param MapperIdInfo The identifier of associated user-defined mapper. 5913 /// \param Locs Locations needed to build a mappable clause. It includes 1) 5914 /// StartLoc: starting location of the clause (the clause keyword); 2) 5915 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 5916 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5917 /// NumVars: number of expressions listed in this clause; 2) 5918 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5919 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5920 /// NumComponents: total number of expression components in the clause. 5921 explicit OMPFromClause(NestedNameSpecifierLoc MapperQualifierLoc, 5922 DeclarationNameInfo MapperIdInfo, 5923 const OMPVarListLocTy &Locs, 5924 const OMPMappableExprListSizeTy &Sizes) 5925 : OMPMappableExprListClause(OMPC_from, Locs, Sizes, &MapperQualifierLoc, 5926 &MapperIdInfo) {} 5927 5928 /// Build an empty clause. 5929 /// 5930 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5931 /// NumVars: number of expressions listed in this clause; 2) 5932 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5933 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5934 /// NumComponents: total number of expression components in the clause. 5935 explicit OMPFromClause(const OMPMappableExprListSizeTy &Sizes) 5936 : OMPMappableExprListClause(OMPC_from, OMPVarListLocTy(), Sizes) {} 5937 5938 /// Define the sizes of each trailing object array except the last one. This 5939 /// is required for TrailingObjects to work properly. 5940 size_t numTrailingObjects(OverloadToken<Expr *>) const { 5941 // There are varlist_size() of expressions, and varlist_size() of 5942 // user-defined mappers. 5943 return 2 * varlist_size(); 5944 } 5945 size_t numTrailingObjects(OverloadToken<ValueDecl *>) const { 5946 return getUniqueDeclarationsNum(); 5947 } 5948 size_t numTrailingObjects(OverloadToken<unsigned>) const { 5949 return getUniqueDeclarationsNum() + getTotalComponentListNum(); 5950 } 5951 5952public: 5953 /// Creates clause with a list of variables \a Vars. 5954 /// 5955 /// \param C AST context. 5956 /// \param Locs Locations needed to build a mappable clause. It includes 1) 5957 /// StartLoc: starting location of the clause (the clause keyword); 2) 5958 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 5959 /// \param Vars The original expression used in the clause. 5960 /// \param Declarations Declarations used in the clause. 5961 /// \param ComponentLists Component lists used in the clause. 5962 /// \param UDMapperRefs References to user-defined mappers associated with 5963 /// expressions used in the clause. 5964 /// \param UDMQualifierLoc C++ nested name specifier for the associated 5965 /// user-defined mapper. 5966 /// \param MapperId The identifier of associated user-defined mapper. 5967 static OMPFromClause *Create(const ASTContext &C, const OMPVarListLocTy &Locs, 5968 ArrayRef<Expr *> Vars, 5969 ArrayRef<ValueDecl *> Declarations, 5970 MappableExprComponentListsRef ComponentLists, 5971 ArrayRef<Expr *> UDMapperRefs, 5972 NestedNameSpecifierLoc UDMQualifierLoc, 5973 DeclarationNameInfo MapperId); 5974 5975 /// Creates an empty clause with the place for \a NumVars variables. 5976 /// 5977 /// \param C AST context. 5978 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 5979 /// NumVars: number of expressions listed in this clause; 2) 5980 /// NumUniqueDeclarations: number of unique base declarations in this clause; 5981 /// 3) NumComponentLists: number of component lists in this clause; and 4) 5982 /// NumComponents: total number of expression components in the clause. 5983 static OMPFromClause *CreateEmpty(const ASTContext &C, 5984 const OMPMappableExprListSizeTy &Sizes); 5985 5986 child_range children() { 5987 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 5988 reinterpret_cast<Stmt **>(varlist_end())); 5989 } 5990 5991 const_child_range children() const { 5992 auto Children = const_cast<OMPFromClause *>(this)->children(); 5993 return const_child_range(Children.begin(), Children.end()); 5994 } 5995 5996 child_range used_children() { 5997 return child_range(child_iterator(), child_iterator()); 5998 } 5999 const_child_range used_children() const { 6000 return const_child_range(const_child_iterator(), const_child_iterator()); 6001 } 6002 6003 static bool classof(const OMPClause *T) { 6004 return T->getClauseKind() == OMPC_from; 6005 } 6006}; 6007 6008/// This represents clause 'use_device_ptr' in the '#pragma omp ...' 6009/// directives. 6010/// 6011/// \code 6012/// #pragma omp target data use_device_ptr(a,b) 6013/// \endcode 6014/// In this example directive '#pragma omp target data' has clause 6015/// 'use_device_ptr' with the variables 'a' and 'b'. 6016class OMPUseDevicePtrClause final 6017 : public OMPMappableExprListClause<OMPUseDevicePtrClause>, 6018 private llvm::TrailingObjects< 6019 OMPUseDevicePtrClause, Expr *, ValueDecl *, unsigned, 6020 OMPClauseMappableExprCommon::MappableComponent> { 6021 friend class OMPClauseReader; 6022 friend OMPMappableExprListClause; 6023 friend OMPVarListClause; 6024 friend TrailingObjects; 6025 6026 /// Build clause with number of variables \a NumVars. 6027 /// 6028 /// \param Locs Locations needed to build a mappable clause. It includes 1) 6029 /// StartLoc: starting location of the clause (the clause keyword); 2) 6030 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 6031 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6032 /// NumVars: number of expressions listed in this clause; 2) 6033 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6034 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6035 /// NumComponents: total number of expression components in the clause. 6036 explicit OMPUseDevicePtrClause(const OMPVarListLocTy &Locs, 6037 const OMPMappableExprListSizeTy &Sizes) 6038 : OMPMappableExprListClause(OMPC_use_device_ptr, Locs, Sizes) {} 6039 6040 /// Build an empty clause. 6041 /// 6042 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6043 /// NumVars: number of expressions listed in this clause; 2) 6044 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6045 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6046 /// NumComponents: total number of expression components in the clause. 6047 explicit OMPUseDevicePtrClause(const OMPMappableExprListSizeTy &Sizes) 6048 : OMPMappableExprListClause(OMPC_use_device_ptr, OMPVarListLocTy(), 6049 Sizes) {} 6050 6051 /// Define the sizes of each trailing object array except the last one. This 6052 /// is required for TrailingObjects to work properly. 6053 size_t numTrailingObjects(OverloadToken<Expr *>) const { 6054 return 3 * varlist_size(); 6055 } 6056 size_t numTrailingObjects(OverloadToken<ValueDecl *>) const { 6057 return getUniqueDeclarationsNum(); 6058 } 6059 size_t numTrailingObjects(OverloadToken<unsigned>) const { 6060 return getUniqueDeclarationsNum() + getTotalComponentListNum(); 6061 } 6062 6063 /// Sets the list of references to private copies with initializers for new 6064 /// private variables. 6065 /// \param VL List of references. 6066 void setPrivateCopies(ArrayRef<Expr *> VL); 6067 6068 /// Gets the list of references to private copies with initializers for new 6069 /// private variables. 6070 MutableArrayRef<Expr *> getPrivateCopies() { 6071 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 6072 } 6073 ArrayRef<const Expr *> getPrivateCopies() const { 6074 return llvm::makeArrayRef(varlist_end(), varlist_size()); 6075 } 6076 6077 /// Sets the list of references to initializer variables for new private 6078 /// variables. 6079 /// \param VL List of references. 6080 void setInits(ArrayRef<Expr *> VL); 6081 6082 /// Gets the list of references to initializer variables for new private 6083 /// variables. 6084 MutableArrayRef<Expr *> getInits() { 6085 return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size()); 6086 } 6087 ArrayRef<const Expr *> getInits() const { 6088 return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size()); 6089 } 6090 6091public: 6092 /// Creates clause with a list of variables \a Vars. 6093 /// 6094 /// \param C AST context. 6095 /// \param Locs Locations needed to build a mappable clause. It includes 1) 6096 /// StartLoc: starting location of the clause (the clause keyword); 2) 6097 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 6098 /// \param Vars The original expression used in the clause. 6099 /// \param PrivateVars Expressions referring to private copies. 6100 /// \param Inits Expressions referring to private copy initializers. 6101 /// \param Declarations Declarations used in the clause. 6102 /// \param ComponentLists Component lists used in the clause. 6103 static OMPUseDevicePtrClause * 6104 Create(const ASTContext &C, const OMPVarListLocTy &Locs, 6105 ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars, 6106 ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations, 6107 MappableExprComponentListsRef ComponentLists); 6108 6109 /// Creates an empty clause with the place for \a NumVars variables. 6110 /// 6111 /// \param C AST context. 6112 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6113 /// NumVars: number of expressions listed in this clause; 2) 6114 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6115 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6116 /// NumComponents: total number of expression components in the clause. 6117 static OMPUseDevicePtrClause * 6118 CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes); 6119 6120 using private_copies_iterator = MutableArrayRef<Expr *>::iterator; 6121 using private_copies_const_iterator = ArrayRef<const Expr *>::iterator; 6122 using private_copies_range = llvm::iterator_range<private_copies_iterator>; 6123 using private_copies_const_range = 6124 llvm::iterator_range<private_copies_const_iterator>; 6125 6126 private_copies_range private_copies() { 6127 return private_copies_range(getPrivateCopies().begin(), 6128 getPrivateCopies().end()); 6129 } 6130 6131 private_copies_const_range private_copies() const { 6132 return private_copies_const_range(getPrivateCopies().begin(), 6133 getPrivateCopies().end()); 6134 } 6135 6136 using inits_iterator = MutableArrayRef<Expr *>::iterator; 6137 using inits_const_iterator = ArrayRef<const Expr *>::iterator; 6138 using inits_range = llvm::iterator_range<inits_iterator>; 6139 using inits_const_range = llvm::iterator_range<inits_const_iterator>; 6140 6141 inits_range inits() { 6142 return inits_range(getInits().begin(), getInits().end()); 6143 } 6144 6145 inits_const_range inits() const { 6146 return inits_const_range(getInits().begin(), getInits().end()); 6147 } 6148 6149 child_range children() { 6150 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 6151 reinterpret_cast<Stmt **>(varlist_end())); 6152 } 6153 6154 const_child_range children() const { 6155 auto Children = const_cast<OMPUseDevicePtrClause *>(this)->children(); 6156 return const_child_range(Children.begin(), Children.end()); 6157 } 6158 6159 child_range used_children() { 6160 return child_range(child_iterator(), child_iterator()); 6161 } 6162 const_child_range used_children() const { 6163 return const_child_range(const_child_iterator(), const_child_iterator()); 6164 } 6165 6166 static bool classof(const OMPClause *T) { 6167 return T->getClauseKind() == OMPC_use_device_ptr; 6168 } 6169}; 6170 6171/// This represents clause 'is_device_ptr' in the '#pragma omp ...' 6172/// directives. 6173/// 6174/// \code 6175/// #pragma omp target is_device_ptr(a,b) 6176/// \endcode 6177/// In this example directive '#pragma omp target' has clause 6178/// 'is_device_ptr' with the variables 'a' and 'b'. 6179class OMPIsDevicePtrClause final 6180 : public OMPMappableExprListClause<OMPIsDevicePtrClause>, 6181 private llvm::TrailingObjects< 6182 OMPIsDevicePtrClause, Expr *, ValueDecl *, unsigned, 6183 OMPClauseMappableExprCommon::MappableComponent> { 6184 friend class OMPClauseReader; 6185 friend OMPMappableExprListClause; 6186 friend OMPVarListClause; 6187 friend TrailingObjects; 6188 6189 /// Build clause with number of variables \a NumVars. 6190 /// 6191 /// \param Locs Locations needed to build a mappable clause. It includes 1) 6192 /// StartLoc: starting location of the clause (the clause keyword); 2) 6193 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 6194 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6195 /// NumVars: number of expressions listed in this clause; 2) 6196 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6197 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6198 /// NumComponents: total number of expression components in the clause. 6199 explicit OMPIsDevicePtrClause(const OMPVarListLocTy &Locs, 6200 const OMPMappableExprListSizeTy &Sizes) 6201 : OMPMappableExprListClause(OMPC_is_device_ptr, Locs, Sizes) {} 6202 6203 /// Build an empty clause. 6204 /// 6205 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6206 /// NumVars: number of expressions listed in this clause; 2) 6207 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6208 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6209 /// NumComponents: total number of expression components in the clause. 6210 explicit OMPIsDevicePtrClause(const OMPMappableExprListSizeTy &Sizes) 6211 : OMPMappableExprListClause(OMPC_is_device_ptr, OMPVarListLocTy(), 6212 Sizes) {} 6213 6214 /// Define the sizes of each trailing object array except the last one. This 6215 /// is required for TrailingObjects to work properly. 6216 size_t numTrailingObjects(OverloadToken<Expr *>) const { 6217 return varlist_size(); 6218 } 6219 size_t numTrailingObjects(OverloadToken<ValueDecl *>) const { 6220 return getUniqueDeclarationsNum(); 6221 } 6222 size_t numTrailingObjects(OverloadToken<unsigned>) const { 6223 return getUniqueDeclarationsNum() + getTotalComponentListNum(); 6224 } 6225 6226public: 6227 /// Creates clause with a list of variables \a Vars. 6228 /// 6229 /// \param C AST context. 6230 /// \param Locs Locations needed to build a mappable clause. It includes 1) 6231 /// StartLoc: starting location of the clause (the clause keyword); 2) 6232 /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause. 6233 /// \param Vars The original expression used in the clause. 6234 /// \param Declarations Declarations used in the clause. 6235 /// \param ComponentLists Component lists used in the clause. 6236 static OMPIsDevicePtrClause * 6237 Create(const ASTContext &C, const OMPVarListLocTy &Locs, 6238 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations, 6239 MappableExprComponentListsRef ComponentLists); 6240 6241 /// Creates an empty clause with the place for \a NumVars variables. 6242 /// 6243 /// \param C AST context. 6244 /// \param Sizes All required sizes to build a mappable clause. It includes 1) 6245 /// NumVars: number of expressions listed in this clause; 2) 6246 /// NumUniqueDeclarations: number of unique base declarations in this clause; 6247 /// 3) NumComponentLists: number of component lists in this clause; and 4) 6248 /// NumComponents: total number of expression components in the clause. 6249 static OMPIsDevicePtrClause * 6250 CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes); 6251 6252 child_range children() { 6253 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 6254 reinterpret_cast<Stmt **>(varlist_end())); 6255 } 6256 6257 const_child_range children() const { 6258 auto Children = const_cast<OMPIsDevicePtrClause *>(this)->children(); 6259 return const_child_range(Children.begin(), Children.end()); 6260 } 6261 6262 child_range used_children() { 6263 return child_range(child_iterator(), child_iterator()); 6264 } 6265 const_child_range used_children() const { 6266 return const_child_range(const_child_iterator(), const_child_iterator()); 6267 } 6268 6269 static bool classof(const OMPClause *T) { 6270 return T->getClauseKind() == OMPC_is_device_ptr; 6271 } 6272}; 6273 6274/// This represents clause 'nontemporal' in the '#pragma omp ...' directives. 6275/// 6276/// \code 6277/// #pragma omp simd nontemporal(a) 6278/// \endcode 6279/// In this example directive '#pragma omp simd' has clause 'nontemporal' for 6280/// the variable 'a'. 6281class OMPNontemporalClause final 6282 : public OMPVarListClause<OMPNontemporalClause>, 6283 private llvm::TrailingObjects<OMPNontemporalClause, Expr *> { 6284 friend class OMPClauseReader; 6285 friend OMPVarListClause; 6286 friend TrailingObjects; 6287 6288 /// Build clause with number of variables \a N. 6289 /// 6290 /// \param StartLoc Starting location of the clause. 6291 /// \param LParenLoc Location of '('. 6292 /// \param EndLoc Ending location of the clause. 6293 /// \param N Number of the variables in the clause. 6294 OMPNontemporalClause(SourceLocation StartLoc, SourceLocation LParenLoc, 6295 SourceLocation EndLoc, unsigned N) 6296 : OMPVarListClause<OMPNontemporalClause>(OMPC_nontemporal, StartLoc, 6297 LParenLoc, EndLoc, N) {} 6298 6299 /// Build an empty clause. 6300 /// 6301 /// \param N Number of variables. 6302 explicit OMPNontemporalClause(unsigned N) 6303 : OMPVarListClause<OMPNontemporalClause>( 6304 OMPC_nontemporal, SourceLocation(), SourceLocation(), 6305 SourceLocation(), N) {} 6306 6307 /// Get the list of privatied copies if the member expression was captured by 6308 /// one of the privatization clauses. 6309 MutableArrayRef<Expr *> getPrivateRefs() { 6310 return MutableArrayRef<Expr *>(varlist_end(), varlist_size()); 6311 } 6312 ArrayRef<const Expr *> getPrivateRefs() const { 6313 return llvm::makeArrayRef(varlist_end(), varlist_size()); 6314 } 6315 6316public: 6317 /// Creates clause with a list of variables \a VL. 6318 /// 6319 /// \param C AST context. 6320 /// \param StartLoc Starting location of the clause. 6321 /// \param LParenLoc Location of '('. 6322 /// \param EndLoc Ending location of the clause. 6323 /// \param VL List of references to the variables. 6324 static OMPNontemporalClause * 6325 Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 6326 SourceLocation EndLoc, ArrayRef<Expr *> VL); 6327 6328 /// Creates an empty clause with the place for \a N variables. 6329 /// 6330 /// \param C AST context. 6331 /// \param N The number of variables. 6332 static OMPNontemporalClause *CreateEmpty(const ASTContext &C, unsigned N); 6333 6334 /// Sets the list of references to private copies created in private clauses. 6335 /// \param VL List of references. 6336 void setPrivateRefs(ArrayRef<Expr *> VL); 6337 6338 child_range children() { 6339 return child_range(reinterpret_cast<Stmt **>(varlist_begin()), 6340 reinterpret_cast<Stmt **>(varlist_end())); 6341 } 6342 6343 const_child_range children() const { 6344 auto Children = const_cast<OMPNontemporalClause *>(this)->children(); 6345 return const_child_range(Children.begin(), Children.end()); 6346 } 6347 6348 child_range private_refs() { 6349 return child_range(reinterpret_cast<Stmt **>(getPrivateRefs().begin()), 6350 reinterpret_cast<Stmt **>(getPrivateRefs().end())); 6351 } 6352 6353 const_child_range private_refs() const { 6354 auto Children = const_cast<OMPNontemporalClause *>(this)->private_refs(); 6355 return const_child_range(Children.begin(), Children.end()); 6356 } 6357 6358 child_range used_children() { 6359 return child_range(child_iterator(), child_iterator()); 6360 } 6361 const_child_range used_children() const { 6362 return const_child_range(const_child_iterator(), const_child_iterator()); 6363 } 6364 6365 static bool classof(const OMPClause *T) { 6366 return T->getClauseKind() == OMPC_nontemporal; 6367 } 6368}; 6369 6370/// This class implements a simple visitor for OMPClause 6371/// subclasses. 6372template<class ImplClass, template <typename> class Ptr, typename RetTy> 6373class OMPClauseVisitorBase { 6374public: 6375#define PTR(CLASS) typename Ptr<CLASS>::type 6376#define DISPATCH(CLASS) \ 6377 return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S)) 6378 6379#define OPENMP_CLAUSE(Name, Class) \ 6380 RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); } 6381#include "clang/Basic/OpenMPKinds.def" 6382 6383 RetTy Visit(PTR(OMPClause) S) { 6384 // Top switch clause: visit each OMPClause. 6385 switch (S->getClauseKind()) { 6386 default: llvm_unreachable("Unknown clause kind!"); 6387#define OPENMP_CLAUSE(Name, Class) \ 6388 case OMPC_ ## Name : return Visit ## Class(static_cast<PTR(Class)>(S)); 6389#include "clang/Basic/OpenMPKinds.def" 6390 } 6391 } 6392 // Base case, ignore it. :) 6393 RetTy VisitOMPClause(PTR(OMPClause) Node) { return RetTy(); } 6394#undef PTR 6395#undef DISPATCH 6396}; 6397 6398template <typename T> 6399using const_ptr = typename std::add_pointer<typename std::add_const<T>::type>; 6400 6401template<class ImplClass, typename RetTy = void> 6402class OMPClauseVisitor : 6403 public OMPClauseVisitorBase <ImplClass, std::add_pointer, RetTy> {}; 6404template<class ImplClass, typename RetTy = void> 6405class ConstOMPClauseVisitor : 6406 public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {}; 6407 6408class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> { 6409 raw_ostream &OS; 6410 const PrintingPolicy &Policy; 6411 6412 /// Process clauses with list of variables. 6413 template <typename T> void VisitOMPClauseList(T *Node, char StartSym); 6414 6415public: 6416 OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy) 6417 : OS(OS), Policy(Policy) {} 6418 6419#define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S); 6420#include "clang/Basic/OpenMPKinds.def" 6421}; 6422 6423} // namespace clang 6424 6425#endif // LLVM_CLANG_AST_OPENMPCLAUSE_H 6426