head 1.1; branch 1.1.1; access; symbols netbsd-10-2-RELEASE:1.1.1.2 netbsd-11-0-RELEASE:1.1.1.2 netbsd-11-0-RC7:1.1.1.2 netbsd-11-0-RC6:1.1.1.2 netbsd-11-0-RC5:1.1.1.2 netbsd-11-0-RC4:1.1.1.2 netbsd-11-0-RC3:1.1.1.2 netbsd-11-0-RC2:1.1.1.2 netbsd-11-0-RC1:1.1.1.2 perseant-exfatfs-base-20250801:1.1.1.2 netbsd-11:1.1.1.2.0.8 netbsd-11-base:1.1.1.2 netbsd-10-1-RELEASE:1.1.1.2 perseant-exfatfs-base-20240630:1.1.1.2 perseant-exfatfs:1.1.1.2.0.6 perseant-exfatfs-base:1.1.1.2 netbsd-10-0-RELEASE:1.1.1.2 netbsd-10-0-RC6:1.1.1.2 netbsd-10-0-RC5:1.1.1.2 netbsd-10-0-RC4:1.1.1.2 netbsd-10-0-RC3:1.1.1.2 netbsd-10-0-RC2:1.1.1.2 netbsd-10-0-RC1:1.1.1.2 netbsd-10:1.1.1.2.0.4 netbsd-10-base:1.1.1.2 cjep_sun2x-base1:1.1.1.2 cjep_sun2x:1.1.1.2.0.2 cjep_sun2x-base:1.1.1.2 cjep_staticlib_x-base1:1.1.1.2 LLVM-249b40b558955afe5ac2b549edcf2d7f859c8cc9:1.1.1.2 cjep_staticlib_x:1.1.1.1.0.4 cjep_staticlib_x-base:1.1.1.1 phil-wifi-20200421:1.1.1.1 phil-wifi-20200411:1.1.1.1 is-mlppp:1.1.1.1.0.2 is-mlppp-base:1.1.1.1 phil-wifi-20200406:1.1.1.1 phil-wifi-20191119:1.1.1.1 LLVM-01f3a59fb3e2542fce74c768718f594d0debd0da:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2019.11.08.14.29.43; author joerg; state Exp; branches 1.1.1.1; next ; commitid lIv69tfiG0KHw3KB; 1.1.1.1 date 2019.11.08.14.29.43; author joerg; state Exp; branches 1.1.1.1.4.1; next 1.1.1.2; commitid lIv69tfiG0KHw3KB; 1.1.1.2 date 2021.05.30.01.25.55; author joerg; state Exp; branches; next ; commitid uhgdinROdC6tU6VC; 1.1.1.1.4.1 date 2021.05.31.22.07.11; author cjep; state Exp; branches; next ; commitid eWz9SBW0XqKjJlVC; desc @@ 1.1 log @Initial revision @ text @//===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the subclesses of Stmt class declared in StmtOpenMP.h // //===----------------------------------------------------------------------===// #include "clang/AST/StmtOpenMP.h" #include "clang/AST/ASTContext.h" using namespace clang; void OMPExecutableDirective::setClauses(ArrayRef Clauses) { assert(Clauses.size() == getNumClauses() && "Number of clauses is not the same as the preallocated buffer"); std::copy(Clauses.begin(), Clauses.end(), getClauses().begin()); } bool OMPExecutableDirective::isStandaloneDirective() const { // Special case: 'omp target enter data', 'omp target exit data', // 'omp target update' are stand-alone directives, but for implementation // reasons they have empty synthetic structured block, to simplify codegen. if (isa(this) || isa(this) || isa(this)) return true; return !hasAssociatedStmt() || !getAssociatedStmt(); } const Stmt *OMPExecutableDirective::getStructuredBlock() const { assert(!isStandaloneDirective() && "Standalone Executable Directives don't have Structured Blocks."); if (auto *LD = dyn_cast(this)) return LD->getBody(); return getInnermostCapturedStmt()->getCapturedStmt(); } void OMPLoopDirective::setCounters(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of loop counters is not the same as the collapsed number"); std::copy(A.begin(), A.end(), getCounters().begin()); } void OMPLoopDirective::setPrivateCounters(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of loop private counters " "is not the same as the collapsed " "number"); std::copy(A.begin(), A.end(), getPrivateCounters().begin()); } void OMPLoopDirective::setInits(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of counter inits is not the same as the collapsed number"); std::copy(A.begin(), A.end(), getInits().begin()); } void OMPLoopDirective::setUpdates(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of counter updates is not the same as the collapsed number"); std::copy(A.begin(), A.end(), getUpdates().begin()); } void OMPLoopDirective::setFinals(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of counter finals is not the same as the collapsed number"); std::copy(A.begin(), A.end(), getFinals().begin()); } void OMPLoopDirective::setDependentCounters(ArrayRef A) { assert( A.size() == getCollapsedNumber() && "Number of dependent counters is not the same as the collapsed number"); llvm::copy(A, getDependentCounters().begin()); } void OMPLoopDirective::setDependentInits(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of dependent inits is not the same as the collapsed number"); llvm::copy(A, getDependentInits().begin()); } void OMPLoopDirective::setFinalsConditions(ArrayRef A) { assert(A.size() == getCollapsedNumber() && "Number of finals conditions is not the same as the collapsed number"); llvm::copy(A, getFinalsConditions().begin()); } OMPParallelDirective *OMPParallelDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPParallelDirective *Dir = new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setHasCancel(HasCancel); return Dir; } OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPParallelDirective(NumClauses); } OMPSimdDirective * OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); OMPSimdDirective *Dir = new (Mem) OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses); } OMPForDirective * OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); OMPForDirective *Dir = new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setHasCancel(HasCancel); return Dir; } OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); return new (Mem) OMPForDirective(CollapsedNum, NumClauses); } OMPForSimdDirective * OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); OMPForSimdDirective *Dir = new (Mem) OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses); } OMPSectionsDirective *OMPSectionsDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPSectionsDirective *Dir = new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setHasCancel(HasCancel); return Dir; } OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPSectionsDirective(NumClauses); } OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *)); OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc); Dir->setAssociatedStmt(AssociatedStmt); Dir->setHasCancel(HasCancel); return Dir; } OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *)); return new (Mem) OMPSectionDirective(); } OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPSingleDirective *Dir = new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPSingleDirective(NumClauses); } OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *)); OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *)); return new (Mem) OMPMasterDirective(); } OMPCriticalDirective *OMPCriticalDirective::Create( const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPCriticalDirective *Dir = new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPCriticalDirective(NumClauses); } OMPParallelForDirective *OMPParallelForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for)); OMPParallelForDirective *Dir = new (Mem) OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setHasCancel(HasCancel); return Dir; } OMPParallelForDirective * OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for)); return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses); } OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPParallelForSimdDirective * OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses); } OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPParallelSectionsDirective *Dir = new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setHasCancel(HasCancel); return Dir; } OMPParallelSectionsDirective * OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPParallelSectionsDirective(NumClauses); } OMPTaskDirective * OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTaskDirective *Dir = new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setHasCancel(HasCancel); return Dir; } OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTaskDirective(NumClauses); } OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc) { void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); OMPTaskyieldDirective *Dir = new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc); return Dir; } OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C, EmptyShell) { void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); return new (Mem) OMPTaskyieldDirective(); } OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc) { void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc); return Dir; } OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C, EmptyShell) { void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); return new (Mem) OMPBarrierDirective(); } OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc) { void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc); return Dir; } OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, EmptyShell) { void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); return new (Mem) OMPTaskwaitDirective(); } OMPTaskgroupDirective *OMPTaskgroupDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) { unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) + sizeof(OMPClause *) * Clauses.size(), alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *)); OMPTaskgroupDirective *Dir = new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc, Clauses.size()); Dir->setAssociatedStmt(AssociatedStmt); Dir->setReductionRef(ReductionRef); Dir->setClauses(Clauses); return Dir; } OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) + sizeof(OMPClause *) * NumClauses, alignof(Stmt *)); void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *)); return new (Mem) OMPTaskgroupDirective(NumClauses); } OMPCancellationPointDirective *OMPCancellationPointDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion) { unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size); OMPCancellationPointDirective *Dir = new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc); Dir->setCancelRegion(CancelRegion); return Dir; } OMPCancellationPointDirective * OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *)); void *Mem = C.Allocate(Size); return new (Mem) OMPCancellationPointDirective(); } OMPCancelDirective * OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, OpenMPDirectiveKind CancelRegion) { unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(), alignof(Stmt *)); void *Mem = C.Allocate(Size); OMPCancelDirective *Dir = new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setCancelRegion(CancelRegion); return Dir; } OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) + sizeof(OMPClause *) * NumClauses, alignof(Stmt *)); void *Mem = C.Allocate(Size); return new (Mem) OMPCancelDirective(NumClauses); } OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { unsigned Size = llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size()); OMPFlushDirective *Dir = new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); return Dir; } OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses); return new (Mem) OMPFlushDirective(NumClauses); } OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size()); OMPOrderedDirective *Dir = new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses); return new (Mem) OMPOrderedDirective(NumClauses); } OMPAtomicDirective *OMPAtomicDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V, Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) { unsigned Size = llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 5 * sizeof(Stmt *)); OMPAtomicDirective *Dir = new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setX(X); Dir->setV(V); Dir->setExpr(E); Dir->setUpdateExpr(UE); Dir->IsXLHSInRHSPart = IsXLHSInRHSPart; Dir->IsPostfixUpdate = IsPostfixUpdate; return Dir; } OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *)); return new (Mem) OMPAtomicDirective(NumClauses); } OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetDirective *Dir = new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTargetDirective(NumClauses); } OMPTargetParallelDirective *OMPTargetParallelDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetParallelDirective *Dir = new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetParallelDirective * OMPTargetParallelDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTargetParallelDirective(NumClauses); } OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for)); OMPTargetParallelForDirective *Dir = new (Mem) OMPTargetParallelForDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setHasCancel(HasCancel); return Dir; } OMPTargetParallelForDirective * OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for)); return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses); } OMPTargetDataDirective *OMPTargetDataDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetDataDirective *Dir = new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C, unsigned N, EmptyShell) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * N + sizeof(Stmt *)); return new (Mem) OMPTargetDataDirective(N); } OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetEnterDataDirective *Dir = new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetEnterDataDirective * OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N, EmptyShell) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * N + sizeof(Stmt *)); return new (Mem) OMPTargetEnterDataDirective(N); } OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetExitDataDirective *Dir = new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetExitDataDirective * OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N, EmptyShell) { void *Mem = C.Allocate( llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) + sizeof(OMPClause *) * N + sizeof(Stmt *)); return new (Mem) OMPTargetExitDataDirective(N); } OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTeamsDirective *Dir = new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTeamsDirective(NumClauses); } OMPTaskLoopDirective *OMPTaskLoopDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop)); OMPTaskLoopDirective *Dir = new (Mem) OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop)); return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses); } OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop_simd)); OMPTaskLoopSimdDirective *Dir = new (Mem) OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTaskLoopSimdDirective * OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop_simd)); return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses); } OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop)); OMPMasterTaskLoopDirective *Dir = new (Mem) OMPMasterTaskLoopDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPMasterTaskLoopDirective * OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop)); return new (Mem) OMPMasterTaskLoopDirective(CollapsedNum, NumClauses); } OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd)); auto *Dir = new (Mem) OMPMasterTaskLoopSimdDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPMasterTaskLoopSimdDirective * OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd)); return new (Mem) OMPMasterTaskLoopSimdDirective(CollapsedNum, NumClauses); } OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop)); auto *Dir = new (Mem) OMPParallelMasterTaskLoopDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPParallelMasterTaskLoopDirective * OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop)); return new (Mem) OMPParallelMasterTaskLoopDirective(CollapsedNum, NumClauses); } OMPDistributeDirective *OMPDistributeDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute)); OMPDistributeDirective *Dir = new (Mem) OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPDistributeDirective * OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute)); return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses); } OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetUpdateDirective *Dir = new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetUpdateDirective * OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTargetUpdateDirective(NumClauses); } OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for)); OMPDistributeParallelForDirective *Dir = new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); Dir->HasCancel = HasCancel; return Dir; } OMPDistributeParallelForDirective * OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for)); return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses); } OMPDistributeParallelForSimdDirective * OMPDistributeParallelForSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd)); OMPDistributeParallelForSimdDirective *Dir = new (Mem) OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); return Dir; } OMPDistributeParallelForSimdDirective * OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd)); return new (Mem) OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses); } OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_simd)); OMPDistributeSimdDirective *Dir = new (Mem) OMPDistributeSimdDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPDistributeSimdDirective * OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_distribute_simd)); return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses); } OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd)); OMPTargetParallelForSimdDirective *Dir = new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTargetParallelForSimdDirective * OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd)); return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses); } OMPTargetSimdDirective * OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_simd)); OMPTargetSimdDirective *Dir = new (Mem) OMPTargetSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTargetSimdDirective * OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_simd)); return new (Mem) OMPTargetSimdDirective(CollapsedNum, NumClauses); } OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute)); OMPTeamsDistributeDirective *Dir = new (Mem) OMPTeamsDistributeDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTeamsDistributeDirective * OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute)); return new (Mem) OMPTeamsDistributeDirective(CollapsedNum, NumClauses); } OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd)); OMPTeamsDistributeSimdDirective *Dir = new (Mem) OMPTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty( const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd)); return new (Mem) OMPTeamsDistributeSimdDirective(CollapsedNum, NumClauses); } OMPTeamsDistributeParallelForSimdDirective * OMPTeamsDistributeParallelForSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd)); OMPTeamsDistributeParallelForSimdDirective *Dir = new (Mem) OMPTeamsDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); return Dir; } OMPTeamsDistributeParallelForSimdDirective * OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd)); return new (Mem) OMPTeamsDistributeParallelForSimdDirective(CollapsedNum, NumClauses); } OMPTeamsDistributeParallelForDirective * OMPTeamsDistributeParallelForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for)); OMPTeamsDistributeParallelForDirective *Dir = new (Mem) OMPTeamsDistributeParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); Dir->HasCancel = HasCancel; return Dir; } OMPTeamsDistributeParallelForDirective * OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for)); return new (Mem) OMPTeamsDistributeParallelForDirective(CollapsedNum, NumClauses); } OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); OMPTargetTeamsDirective *Dir = new (Mem) OMPTargetTeamsDirective(StartLoc, EndLoc, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); return Dir; } OMPTargetTeamsDirective * OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *)); void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); return new (Mem) OMPTargetTeamsDirective(NumClauses); } OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute)); OMPTargetTeamsDistributeDirective *Dir = new (Mem) OMPTargetTeamsDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTargetTeamsDistributeDirective * OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute)); return new (Mem) OMPTargetTeamsDistributeDirective(CollapsedNum, NumClauses); } OMPTargetTeamsDistributeParallelForDirective * OMPTargetTeamsDistributeParallelForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for)); OMPTargetTeamsDistributeParallelForDirective *Dir = new (Mem) OMPTargetTeamsDistributeParallelForDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); Dir->HasCancel = HasCancel; return Dir; } OMPTargetTeamsDistributeParallelForDirective * OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for)); return new (Mem) OMPTargetTeamsDistributeParallelForDirective(CollapsedNum, NumClauses); } OMPTargetTeamsDistributeParallelForSimdDirective * OMPTargetTeamsDistributeParallelForSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd)); OMPTargetTeamsDistributeParallelForSimdDirective *Dir = new (Mem) OMPTargetTeamsDistributeParallelForSimdDirective( StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setPrevLowerBoundVariable(Exprs.PrevLB); Dir->setPrevUpperBoundVariable(Exprs.PrevUB); Dir->setDistInc(Exprs.DistInc); Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); Dir->setCombinedInit(Exprs.DistCombinedFields.Init); Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); return Dir; } OMPTargetTeamsDistributeParallelForSimdDirective * OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd)); return new (Mem) OMPTargetTeamsDistributeParallelForSimdDirective( CollapsedNum, NumClauses); } OMPTargetTeamsDistributeSimdDirective * OMPTargetTeamsDistributeSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd)); OMPTargetTeamsDistributeSimdDirective *Dir = new (Mem) OMPTargetTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); Dir->setClauses(Clauses); Dir->setAssociatedStmt(AssociatedStmt); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPTargetTeamsDistributeSimdDirective * OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective), alignof(OMPClause *)); void *Mem = C.Allocate( Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd)); return new (Mem) OMPTargetTeamsDistributeSimdDirective(CollapsedNum, NumClauses); } @ 1.1.1.1 log @Import 01f3a59fb3e2542fce74c768718f594d0debd0da from the LLVM mono-repo: clang (without test/, unittests/, www/) llvm (without test/, unittests/) @ text @@ 1.1.1.1.4.1 log @sync with head @ text @d13 2 a15 1 #include "clang/AST/StmtOpenMP.h" a17 9 using namespace llvm::omp; size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt, unsigned NumChildren) { return llvm::alignTo( totalSizeToAlloc( NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)), alignof(OMPChildren)); } d19 2 a20 2 void OMPChildren::setClauses(ArrayRef Clauses) { assert(Clauses.size() == NumClauses && d22 1 a22 26 llvm::copy(Clauses, getTrailingObjects()); } MutableArrayRef OMPChildren::getChildren() { return llvm::makeMutableArrayRef(getTrailingObjects(), NumChildren); } OMPChildren *OMPChildren::Create(void *Mem, ArrayRef Clauses) { auto *Data = CreateEmpty(Mem, Clauses.size()); Data->setClauses(Clauses); return Data; } OMPChildren *OMPChildren::Create(void *Mem, ArrayRef Clauses, Stmt *S, unsigned NumChildren) { auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren); Data->setClauses(Clauses); if (S) Data->setAssociatedStmt(S); return Data; } OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses, bool HasAssociatedStmt, unsigned NumChildren) { return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt); d33 1 a33 1 return !hasAssociatedStmt(); d36 1 a36 1 Stmt *OMPExecutableDirective::getStructuredBlock() { d41 1 a41 111 return getRawStmt(); } Stmt * OMPLoopBasedDirective::tryToFindNextInnerLoop(Stmt *CurStmt, bool TryImperfectlyNestedLoops) { Stmt *OrigStmt = CurStmt; CurStmt = CurStmt->IgnoreContainers(); // Additional work for imperfectly nested loops, introduced in OpenMP 5.0. if (TryImperfectlyNestedLoops) { if (auto *CS = dyn_cast(CurStmt)) { CurStmt = nullptr; SmallVector Statements(1, CS); SmallVector NextStatements; while (!Statements.empty()) { CS = Statements.pop_back_val(); if (!CS) continue; for (Stmt *S : CS->body()) { if (!S) continue; if (auto *CanonLoop = dyn_cast(S)) S = CanonLoop->getLoopStmt(); if (isa(S) || isa(S) || (isa(S) && !isa(S))) { // Only single loop construct is allowed. if (CurStmt) { CurStmt = OrigStmt; break; } CurStmt = S; continue; } S = S->IgnoreContainers(); if (auto *InnerCS = dyn_cast_or_null(S)) NextStatements.push_back(InnerCS); } if (Statements.empty()) { // Found single inner loop or multiple loops - exit. if (CurStmt) break; Statements.swap(NextStatements); } } if (!CurStmt) CurStmt = OrigStmt; } } return CurStmt; } bool OMPLoopBasedDirective::doForAllLoops( Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref Callback) { CurStmt = CurStmt->IgnoreContainers(); for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) { if (auto *Dir = dyn_cast(CurStmt)) CurStmt = Dir->getTransformedStmt(); if (auto *CanonLoop = dyn_cast(CurStmt)) CurStmt = CanonLoop->getLoopStmt(); if (Callback(Cnt, CurStmt)) return false; // Move on to the next nested for loop, or to the loop body. // OpenMP [2.8.1, simd construct, Restrictions] // All loops associated with the construct must be perfectly nested; that // is, there must be no intervening code nor any OpenMP directive between // any two loops. if (auto *For = dyn_cast(CurStmt)) { CurStmt = For->getBody(); } else { assert(isa(CurStmt) && "Expected canonical for or range-based for loops."); CurStmt = cast(CurStmt)->getBody(); } CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop( CurStmt, TryImperfectlyNestedLoops); } return true; } void OMPLoopBasedDirective::doForAllLoopsBodies( Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref Callback) { bool Res = OMPLoopBasedDirective::doForAllLoops( CurStmt, TryImperfectlyNestedLoops, NumLoops, [Callback](unsigned Cnt, Stmt *Loop) { Stmt *Body = nullptr; if (auto *For = dyn_cast(Loop)) { Body = For->getBody(); } else { assert(isa(Loop) && "Expected canonical for or range-based for loops."); Body = cast(Loop)->getBody(); } if (auto *CanonLoop = dyn_cast(Body)) Body = CanonLoop->getLoopStmt(); Callback(Cnt, Loop, Body); return false; }); assert(Res && "Expected only loops"); (void)Res; } Stmt *OMPLoopDirective::getBody() { // This relies on the loop form is already checked by Sema. Stmt *Body = nullptr; OMPLoopBasedDirective::doForAllLoopsBodies( Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true, NumAssociatedLoops, [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; }); return Body; d45 1 a45 1 assert(A.size() == getLoopsNumber() && d47 1 a47 1 llvm::copy(A, getCounters().begin()); d51 4 a54 4 assert(A.size() == getLoopsNumber() && "Number of loop private counters " "is not the same as the collapsed " "number"); llvm::copy(A, getPrivateCounters().begin()); d58 1 a58 1 assert(A.size() == getLoopsNumber() && d60 1 a60 1 llvm::copy(A, getInits().begin()); d64 1 a64 1 assert(A.size() == getLoopsNumber() && d66 1 a66 1 llvm::copy(A, getUpdates().begin()); d70 1 a70 1 assert(A.size() == getLoopsNumber() && d72 1 a72 1 llvm::copy(A, getFinals().begin()); d77 1 a77 1 A.size() == getLoopsNumber() && d83 1 a83 1 assert(A.size() == getLoopsNumber() && d89 1 a89 1 assert(A.size() == getLoopsNumber() && d96 9 a104 5 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d112 5 a116 3 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d124 8 a131 3 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd), StartLoc, EndLoc, CollapsedNum); d155 20 a174 12 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum); } OMPForDirective *OMPForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1, StartLoc, EndLoc, CollapsedNum); a198 1 Dir->setTaskReductionRefExpr(TaskRedRef); d207 5 a211 24 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum); } OMPTileDirective * OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits) { OMPTileDirective *Dir = createDirective( C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc, NumLoops); Dir->setTransformedStmt(TransformedStmt); Dir->setPreInits(PreInits); return Dir; } OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1, SourceLocation(), SourceLocation(), NumLoops); d219 9 a227 3 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd), StartLoc, EndLoc, CollapsedNum); d259 6 a264 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum); d269 9 a277 6 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d285 5 a289 3 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d297 4 a300 3 auto *Dir = createDirective(C, llvm::None, AssociatedStmt, /*NumChildre=*/0, StartLoc, EndLoc); d307 3 a309 2 return createEmptyDirective(C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true); d317 9 a325 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d331 5 a335 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d342 5 a346 3 return createDirective(C, llvm::None, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d351 3 a353 2 return createEmptyDirective(C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true); d360 9 a368 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, Name, StartLoc, EndLoc); d374 5 a378 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d384 10 a393 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a417 1 Dir->setTaskReductionRefExpr(TaskRedRef); d425 6 a430 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum); d437 9 a445 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d477 6 a482 19 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum); } OMPParallelMasterDirective *OMPParallelMasterDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); return Dir; } OMPParallelMasterDirective * OMPParallelMasterDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d487 9 a495 5 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d503 5 a507 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d514 7 a520 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d528 4 a531 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d537 4 a540 1 return new (C) OMPTaskyieldDirective(StartLoc, EndLoc); d545 2 a546 1 return new (C) OMPTaskyieldDirective(); d552 3 a554 1 return new (C) OMPBarrierDirective(StartLoc, EndLoc); d559 2 a560 1 return new (C) OMPBarrierDirective(); d566 3 a568 1 return new (C) OMPTaskwaitDirective(StartLoc, EndLoc); d573 2 a574 1 return new (C) OMPTaskwaitDirective(); d580 7 a586 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); d588 1 d595 5 a599 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d605 5 a609 1 auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc); d616 4 a619 1 return new (C) OMPCancellationPointDirective(); d626 7 a632 3 auto *Dir = createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); d640 5 a644 1 return createEmptyDirective(C, NumClauses); d651 7 a657 3 return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); d663 4 a666 31 return createEmptyDirective(C, NumClauses); } OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); } OMPScanDirective *OMPScanDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective(C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); d674 9 a682 3 return createDirective( C, Clauses, cast_or_null(AssociatedStmt), /*NumChildren=*/0, StartLoc, EndLoc); a686 1 bool IsStandalone, d688 5 a692 2 return createEmptyDirective(C, NumClauses, !IsStandalone); d699 8 a706 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc); d719 5 a723 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4); d731 9 a739 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d745 5 a749 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d754 9 a762 6 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); Dir->setHasCancel(HasCancel); d769 5 a773 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d779 10 a788 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a812 1 Dir->setTaskReductionRefExpr(TaskRedRef); d821 6 a826 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, CollapsedNum); d832 8 a839 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d845 4 a848 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d854 8 a861 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d867 4 a870 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d876 8 a883 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d889 4 a892 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d900 9 a908 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d914 5 a918 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d924 10 a933 4 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop), StartLoc, EndLoc, CollapsedNum); a957 1 Dir->setHasCancel(HasCancel); d965 6 a970 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum); d977 9 a985 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc, CollapsedNum); d1016 6 a1021 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum); d1027 10 a1036 5 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc, CollapsedNum); a1060 1 Dir->setHasCancel(HasCancel); d1068 6 a1073 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum); d1080 10 a1089 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc, EndLoc, CollapsedNum); d1121 7 a1127 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum); d1133 11 a1143 5 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc, EndLoc, CollapsedNum); a1167 1 Dir->setHasCancel(HasCancel); d1176 7 a1182 51 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), CollapsedNum); } OMPParallelMasterTaskLoopSimdDirective * OMPParallelMasterTaskLoopSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), StartLoc, EndLoc, CollapsedNum); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPParallelMasterTaskLoopSimdDirective * OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), CollapsedNum); d1189 9 a1197 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc, CollapsedNum); d1228 6 a1233 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum); d1239 9 a1247 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d1253 5 a1257 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true); d1263 12 a1274 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1311 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1321 7 a1327 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, CollapsedNum); d1335 11 a1345 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1391 8 a1398 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), CollapsedNum); d1405 10 a1414 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc, CollapsedNum); d1446 7 a1452 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum); d1459 11 a1469 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1502 7 a1508 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), CollapsedNum); d1516 9 a1524 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc, CollapsedNum); d1547 6 a1552 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum); d1559 9 a1567 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc, CollapsedNum); d1599 6 a1604 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum); d1611 11 a1621 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc, EndLoc, CollapsedNum); d1652 7 a1658 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum); d1666 12 a1677 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1723 9 a1731 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), CollapsedNum); d1738 12 a1749 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1786 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1796 8 a1803 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, CollapsedNum); d1809 9 a1817 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d1823 5 a1827 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true); d1834 11 a1844 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc, EndLoc, CollapsedNum); d1877 7 a1883 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), CollapsedNum); d1890 14 a1903 6 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1940 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1950 10 a1959 5 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1, CollapsedNum); d1967 13 a1979 5 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d2024 10 a2033 5 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd), CollapsedNum); d2041 11 a2051 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), StartLoc, EndLoc, CollapsedNum); d2084 8 a2091 54 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), CollapsedNum); } OMPInteropDirective * OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); } OMPDispatchDirective *OMPDispatchDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, SourceLocation TargetCallLoc) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); Dir->setTargetCallLoc(TargetCallLoc); return Dir; } OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/0); } OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); } OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); @ 1.1.1.2 log @Import clang 249b40b558955afe5ac2b549edcf2d7f859c8cc9. @ text @d13 2 a15 1 #include "clang/AST/StmtOpenMP.h" a17 9 using namespace llvm::omp; size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt, unsigned NumChildren) { return llvm::alignTo( totalSizeToAlloc( NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)), alignof(OMPChildren)); } d19 2 a20 2 void OMPChildren::setClauses(ArrayRef Clauses) { assert(Clauses.size() == NumClauses && d22 1 a22 26 llvm::copy(Clauses, getTrailingObjects()); } MutableArrayRef OMPChildren::getChildren() { return llvm::makeMutableArrayRef(getTrailingObjects(), NumChildren); } OMPChildren *OMPChildren::Create(void *Mem, ArrayRef Clauses) { auto *Data = CreateEmpty(Mem, Clauses.size()); Data->setClauses(Clauses); return Data; } OMPChildren *OMPChildren::Create(void *Mem, ArrayRef Clauses, Stmt *S, unsigned NumChildren) { auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren); Data->setClauses(Clauses); if (S) Data->setAssociatedStmt(S); return Data; } OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses, bool HasAssociatedStmt, unsigned NumChildren) { return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt); d33 1 a33 1 return !hasAssociatedStmt(); d36 1 a36 1 Stmt *OMPExecutableDirective::getStructuredBlock() { d41 1 a41 111 return getRawStmt(); } Stmt * OMPLoopBasedDirective::tryToFindNextInnerLoop(Stmt *CurStmt, bool TryImperfectlyNestedLoops) { Stmt *OrigStmt = CurStmt; CurStmt = CurStmt->IgnoreContainers(); // Additional work for imperfectly nested loops, introduced in OpenMP 5.0. if (TryImperfectlyNestedLoops) { if (auto *CS = dyn_cast(CurStmt)) { CurStmt = nullptr; SmallVector Statements(1, CS); SmallVector NextStatements; while (!Statements.empty()) { CS = Statements.pop_back_val(); if (!CS) continue; for (Stmt *S : CS->body()) { if (!S) continue; if (auto *CanonLoop = dyn_cast(S)) S = CanonLoop->getLoopStmt(); if (isa(S) || isa(S) || (isa(S) && !isa(S))) { // Only single loop construct is allowed. if (CurStmt) { CurStmt = OrigStmt; break; } CurStmt = S; continue; } S = S->IgnoreContainers(); if (auto *InnerCS = dyn_cast_or_null(S)) NextStatements.push_back(InnerCS); } if (Statements.empty()) { // Found single inner loop or multiple loops - exit. if (CurStmt) break; Statements.swap(NextStatements); } } if (!CurStmt) CurStmt = OrigStmt; } } return CurStmt; } bool OMPLoopBasedDirective::doForAllLoops( Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref Callback) { CurStmt = CurStmt->IgnoreContainers(); for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) { if (auto *Dir = dyn_cast(CurStmt)) CurStmt = Dir->getTransformedStmt(); if (auto *CanonLoop = dyn_cast(CurStmt)) CurStmt = CanonLoop->getLoopStmt(); if (Callback(Cnt, CurStmt)) return false; // Move on to the next nested for loop, or to the loop body. // OpenMP [2.8.1, simd construct, Restrictions] // All loops associated with the construct must be perfectly nested; that // is, there must be no intervening code nor any OpenMP directive between // any two loops. if (auto *For = dyn_cast(CurStmt)) { CurStmt = For->getBody(); } else { assert(isa(CurStmt) && "Expected canonical for or range-based for loops."); CurStmt = cast(CurStmt)->getBody(); } CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop( CurStmt, TryImperfectlyNestedLoops); } return true; } void OMPLoopBasedDirective::doForAllLoopsBodies( Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref Callback) { bool Res = OMPLoopBasedDirective::doForAllLoops( CurStmt, TryImperfectlyNestedLoops, NumLoops, [Callback](unsigned Cnt, Stmt *Loop) { Stmt *Body = nullptr; if (auto *For = dyn_cast(Loop)) { Body = For->getBody(); } else { assert(isa(Loop) && "Expected canonical for or range-based for loops."); Body = cast(Loop)->getBody(); } if (auto *CanonLoop = dyn_cast(Body)) Body = CanonLoop->getLoopStmt(); Callback(Cnt, Loop, Body); return false; }); assert(Res && "Expected only loops"); (void)Res; } Stmt *OMPLoopDirective::getBody() { // This relies on the loop form is already checked by Sema. Stmt *Body = nullptr; OMPLoopBasedDirective::doForAllLoopsBodies( Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true, NumAssociatedLoops, [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; }); return Body; d45 1 a45 1 assert(A.size() == getLoopsNumber() && d47 1 a47 1 llvm::copy(A, getCounters().begin()); d51 4 a54 4 assert(A.size() == getLoopsNumber() && "Number of loop private counters " "is not the same as the collapsed " "number"); llvm::copy(A, getPrivateCounters().begin()); d58 1 a58 1 assert(A.size() == getLoopsNumber() && d60 1 a60 1 llvm::copy(A, getInits().begin()); d64 1 a64 1 assert(A.size() == getLoopsNumber() && d66 1 a66 1 llvm::copy(A, getUpdates().begin()); d70 1 a70 1 assert(A.size() == getLoopsNumber() && d72 1 a72 1 llvm::copy(A, getFinals().begin()); d77 1 a77 1 A.size() == getLoopsNumber() && d83 1 a83 1 assert(A.size() == getLoopsNumber() && d89 1 a89 1 assert(A.size() == getLoopsNumber() && d96 9 a104 5 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d112 5 a116 3 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d124 8 a131 3 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd), StartLoc, EndLoc, CollapsedNum); d155 20 a174 12 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum); } OMPForDirective *OMPForDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1, StartLoc, EndLoc, CollapsedNum); a198 1 Dir->setTaskReductionRefExpr(TaskRedRef); d207 5 a211 24 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum); } OMPTileDirective * OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits) { OMPTileDirective *Dir = createDirective( C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc, NumLoops); Dir->setTransformedStmt(TransformedStmt); Dir->setPreInits(PreInits); return Dir; } OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1, SourceLocation(), SourceLocation(), NumLoops); d219 9 a227 3 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd), StartLoc, EndLoc, CollapsedNum); d259 6 a264 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum); d269 9 a277 6 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d285 5 a289 3 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d297 4 a300 3 auto *Dir = createDirective(C, llvm::None, AssociatedStmt, /*NumChildre=*/0, StartLoc, EndLoc); d307 3 a309 2 return createEmptyDirective(C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true); d317 9 a325 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d331 5 a335 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d342 5 a346 3 return createDirective(C, llvm::None, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d351 3 a353 2 return createEmptyDirective(C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true); d360 9 a368 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, Name, StartLoc, EndLoc); d374 5 a378 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d384 10 a393 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a417 1 Dir->setTaskReductionRefExpr(TaskRedRef); d425 6 a430 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum); d437 9 a445 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d477 6 a482 19 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum); } OMPParallelMasterDirective *OMPParallelMasterDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); return Dir; } OMPParallelMasterDirective * OMPParallelMasterDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d487 9 a495 5 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); d503 5 a507 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d514 7 a520 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d528 4 a531 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d537 4 a540 1 return new (C) OMPTaskyieldDirective(StartLoc, EndLoc); d545 2 a546 1 return new (C) OMPTaskyieldDirective(); d552 3 a554 1 return new (C) OMPBarrierDirective(StartLoc, EndLoc); d559 2 a560 1 return new (C) OMPBarrierDirective(); d566 3 a568 1 return new (C) OMPTaskwaitDirective(StartLoc, EndLoc); d573 2 a574 1 return new (C) OMPTaskwaitDirective(); d580 7 a586 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); d588 1 d595 5 a599 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d605 5 a609 1 auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc); d616 4 a619 1 return new (C) OMPCancellationPointDirective(); d626 7 a632 3 auto *Dir = createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); d640 5 a644 1 return createEmptyDirective(C, NumClauses); d651 7 a657 3 return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); d663 4 a666 31 return createEmptyDirective(C, NumClauses); } OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); } OMPScanDirective *OMPScanDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective(C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); d674 9 a682 3 return createDirective( C, Clauses, cast_or_null(AssociatedStmt), /*NumChildren=*/0, StartLoc, EndLoc); a686 1 bool IsStandalone, d688 5 a692 2 return createEmptyDirective(C, NumClauses, !IsStandalone); d699 8 a706 2 auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc); d719 5 a723 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4); d731 9 a739 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d745 5 a749 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d754 9 a762 6 ArrayRef Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); Dir->setTaskReductionRefExpr(TaskRedRef); Dir->setHasCancel(HasCancel); d769 5 a773 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); d779 10 a788 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a812 1 Dir->setTaskReductionRefExpr(TaskRedRef); d821 6 a826 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, CollapsedNum); d832 8 a839 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d845 4 a848 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d854 8 a861 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d867 4 a870 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d876 8 a883 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d889 4 a892 2 return createEmptyDirective( C, N, /*HasAssociatedStmt=*/true); d900 9 a908 2 return createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d914 5 a918 2 return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); d924 10 a933 4 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop), StartLoc, EndLoc, CollapsedNum); a957 1 Dir->setHasCancel(HasCancel); d965 6 a970 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum); d977 9 a985 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc, CollapsedNum); d1016 6 a1021 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum); d1027 10 a1036 5 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc, CollapsedNum); a1060 1 Dir->setHasCancel(HasCancel); d1068 6 a1073 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum); d1080 10 a1089 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc, EndLoc, CollapsedNum); d1121 7 a1127 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum); d1133 11 a1143 5 const HelperExprs &Exprs, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc, EndLoc, CollapsedNum); a1167 1 Dir->setHasCancel(HasCancel); d1176 7 a1182 51 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), CollapsedNum); } OMPParallelMasterTaskLoopSimdDirective * OMPParallelMasterTaskLoopSimdDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), StartLoc, EndLoc, CollapsedNum); Dir->setIterationVariable(Exprs.IterationVarRef); Dir->setLastIteration(Exprs.LastIteration); Dir->setCalcLastIteration(Exprs.CalcLastIteration); Dir->setPreCond(Exprs.PreCond); Dir->setCond(Exprs.Cond); Dir->setInit(Exprs.Init); Dir->setInc(Exprs.Inc); Dir->setIsLastIterVariable(Exprs.IL); Dir->setLowerBoundVariable(Exprs.LB); Dir->setUpperBoundVariable(Exprs.UB); Dir->setStrideVariable(Exprs.ST); Dir->setEnsureUpperBound(Exprs.EUB); Dir->setNextLowerBound(Exprs.NLB); Dir->setNextUpperBound(Exprs.NUB); Dir->setNumIterations(Exprs.NumIterations); Dir->setCounters(Exprs.Counters); Dir->setPrivateCounters(Exprs.PrivateCounters); Dir->setInits(Exprs.Inits); Dir->setUpdates(Exprs.Updates); Dir->setFinals(Exprs.Finals); Dir->setDependentCounters(Exprs.DependentCounters); Dir->setDependentInits(Exprs.DependentInits); Dir->setFinalsConditions(Exprs.FinalsConditions); Dir->setPreInits(Exprs.PreInits); return Dir; } OMPParallelMasterTaskLoopSimdDirective * OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell) { return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), CollapsedNum); d1189 9 a1197 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc, CollapsedNum); d1228 6 a1233 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum); d1239 9 a1247 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d1253 5 a1257 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true); d1263 12 a1274 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1311 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1321 7 a1327 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, CollapsedNum); d1335 11 a1345 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1391 8 a1398 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), CollapsedNum); d1405 10 a1414 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc, CollapsedNum); d1446 7 a1452 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum); d1459 11 a1469 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1502 7 a1508 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), CollapsedNum); d1516 9 a1524 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc, CollapsedNum); d1547 6 a1552 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum); d1559 9 a1567 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc, CollapsedNum); d1599 6 a1604 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum); d1611 11 a1621 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc, EndLoc, CollapsedNum); d1652 7 a1658 3 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum); d1666 12 a1677 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d1723 9 a1731 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), CollapsedNum); d1738 12 a1749 5 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1786 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1796 8 a1803 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, CollapsedNum); d1809 9 a1817 3 return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); d1823 5 a1827 2 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true); d1834 11 a1844 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc, EndLoc, CollapsedNum); d1877 7 a1883 4 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), CollapsedNum); d1890 14 a1903 6 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1, StartLoc, EndLoc, CollapsedNum); a1940 1 Dir->setTaskReductionRefExpr(TaskRedRef); d1950 10 a1959 5 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1, CollapsedNum); d1967 13 a1979 5 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd), StartLoc, EndLoc, CollapsedNum); d2024 10 a2033 5 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for_simd), CollapsedNum); d2041 11 a2051 4 auto *Dir = createDirective( C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), StartLoc, EndLoc, CollapsedNum); d2084 8 a2091 54 return createEmptyDirective( C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), CollapsedNum); } OMPInteropDirective * OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses) { return createDirective( C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, EndLoc); } OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses); } OMPDispatchDirective *OMPDispatchDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt, SourceLocation TargetCallLoc) { auto *Dir = createDirective( C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); Dir->setTargetCallLoc(TargetCallLoc); return Dir; } OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/0); } OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef Clauses, Stmt *AssociatedStmt) { return createDirective(C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); } OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell) { return createEmptyDirective(C, NumClauses, /*HasAssociatedStmt=*/true); @