418 lines
17 KiB
C++
418 lines
17 KiB
C++
//===--- OpenMPClause.cpp - Classes for OpenMP clauses --------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the subclesses of Stmt class declared in OpenMPClause.h
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/OpenMPClause.h"
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
using namespace clang;
|
|
|
|
OMPClause::child_range OMPClause::children() {
|
|
switch (getClauseKind()) {
|
|
default:
|
|
break;
|
|
#define OPENMP_CLAUSE(Name, Class) \
|
|
case OMPC_##Name: \
|
|
return static_cast<Class *>(this)->children();
|
|
#include "clang/Basic/OpenMPKinds.def"
|
|
}
|
|
llvm_unreachable("unknown OMPClause");
|
|
}
|
|
|
|
void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
|
|
assert(VL.size() == varlist_size() &&
|
|
"Number of private copies is not the same as the preallocated buffer");
|
|
std::copy(VL.begin(), VL.end(), varlist_end());
|
|
}
|
|
|
|
OMPPrivateClause *
|
|
OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
|
|
SourceLocation LParenLoc, SourceLocation EndLoc,
|
|
ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
|
|
// Allocate space for private variables and initializer expressions.
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
|
|
OMPPrivateClause *Clause =
|
|
new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setPrivateCopies(PrivateVL);
|
|
return Clause;
|
|
}
|
|
|
|
OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
|
|
unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
|
|
return new (Mem) OMPPrivateClause(N);
|
|
}
|
|
|
|
void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
|
|
assert(VL.size() == varlist_size() &&
|
|
"Number of private copies is not the same as the preallocated buffer");
|
|
std::copy(VL.begin(), VL.end(), varlist_end());
|
|
}
|
|
|
|
void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
|
|
assert(VL.size() == varlist_size() &&
|
|
"Number of inits is not the same as the preallocated buffer");
|
|
std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
|
|
}
|
|
|
|
OMPFirstprivateClause *
|
|
OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
|
|
SourceLocation LParenLoc, SourceLocation EndLoc,
|
|
ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
|
|
ArrayRef<Expr *> InitVL) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
|
|
OMPFirstprivateClause *Clause =
|
|
new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setPrivateCopies(PrivateVL);
|
|
Clause->setInits(InitVL);
|
|
return Clause;
|
|
}
|
|
|
|
OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
|
|
unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
|
|
return new (Mem) OMPFirstprivateClause(N);
|
|
}
|
|
|
|
void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
|
|
assert(PrivateCopies.size() == varlist_size() &&
|
|
"Number of private copies is not the same as the preallocated buffer");
|
|
std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
|
|
}
|
|
|
|
void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
|
|
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
|
|
"not the same as the "
|
|
"preallocated buffer");
|
|
std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
|
|
}
|
|
|
|
void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
|
|
assert(DstExprs.size() == varlist_size() && "Number of destination "
|
|
"expressions is not the same as "
|
|
"the preallocated buffer");
|
|
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
|
|
}
|
|
|
|
void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
|
|
assert(AssignmentOps.size() == varlist_size() &&
|
|
"Number of assignment expressions is not the same as the preallocated "
|
|
"buffer");
|
|
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
|
|
getDestinationExprs().end());
|
|
}
|
|
|
|
OMPLastprivateClause *OMPLastprivateClause::Create(
|
|
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
|
|
SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
|
|
ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
|
|
OMPLastprivateClause *Clause =
|
|
new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setSourceExprs(SrcExprs);
|
|
Clause->setDestinationExprs(DstExprs);
|
|
Clause->setAssignmentOps(AssignmentOps);
|
|
return Clause;
|
|
}
|
|
|
|
OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
|
|
unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
|
|
return new (Mem) OMPLastprivateClause(N);
|
|
}
|
|
|
|
OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
|
|
SourceLocation StartLoc,
|
|
SourceLocation LParenLoc,
|
|
SourceLocation EndLoc,
|
|
ArrayRef<Expr *> VL) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
|
|
OMPSharedClause *Clause =
|
|
new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
return Clause;
|
|
}
|
|
|
|
OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
|
|
return new (Mem) OMPSharedClause(N);
|
|
}
|
|
|
|
void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
|
|
assert(PL.size() == varlist_size() &&
|
|
"Number of privates is not the same as the preallocated buffer");
|
|
std::copy(PL.begin(), PL.end(), varlist_end());
|
|
}
|
|
|
|
void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
|
|
assert(IL.size() == varlist_size() &&
|
|
"Number of inits is not the same as the preallocated buffer");
|
|
std::copy(IL.begin(), IL.end(), getPrivates().end());
|
|
}
|
|
|
|
void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
|
|
assert(UL.size() == varlist_size() &&
|
|
"Number of updates is not the same as the preallocated buffer");
|
|
std::copy(UL.begin(), UL.end(), getInits().end());
|
|
}
|
|
|
|
void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
|
|
assert(FL.size() == varlist_size() &&
|
|
"Number of final updates is not the same as the preallocated buffer");
|
|
std::copy(FL.begin(), FL.end(), getUpdates().end());
|
|
}
|
|
|
|
OMPLinearClause *OMPLinearClause::Create(
|
|
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
|
|
OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
|
|
SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
|
|
ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) {
|
|
// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
|
|
// (Step and CalcStep).
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
|
|
OMPLinearClause *Clause = new (Mem) OMPLinearClause(
|
|
StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setPrivates(PL);
|
|
Clause->setInits(IL);
|
|
// Fill update and final expressions with zeroes, they are provided later,
|
|
// after the directive construction.
|
|
std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
|
|
nullptr);
|
|
std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
|
|
nullptr);
|
|
Clause->setStep(Step);
|
|
Clause->setCalcStep(CalcStep);
|
|
return Clause;
|
|
}
|
|
|
|
OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
|
|
unsigned NumVars) {
|
|
// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
|
|
// (Step and CalcStep).
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
|
|
return new (Mem) OMPLinearClause(NumVars);
|
|
}
|
|
|
|
OMPAlignedClause *
|
|
OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
|
|
SourceLocation LParenLoc, SourceLocation ColonLoc,
|
|
SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
|
|
OMPAlignedClause *Clause = new (Mem)
|
|
OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setAlignment(A);
|
|
return Clause;
|
|
}
|
|
|
|
OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
|
|
unsigned NumVars) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
|
|
return new (Mem) OMPAlignedClause(NumVars);
|
|
}
|
|
|
|
void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
|
|
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
|
|
"not the same as the "
|
|
"preallocated buffer");
|
|
std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
|
|
}
|
|
|
|
void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
|
|
assert(DstExprs.size() == varlist_size() && "Number of destination "
|
|
"expressions is not the same as "
|
|
"the preallocated buffer");
|
|
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
|
|
}
|
|
|
|
void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
|
|
assert(AssignmentOps.size() == varlist_size() &&
|
|
"Number of assignment expressions is not the same as the preallocated "
|
|
"buffer");
|
|
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
|
|
getDestinationExprs().end());
|
|
}
|
|
|
|
OMPCopyinClause *OMPCopyinClause::Create(
|
|
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
|
|
SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
|
|
ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
|
|
OMPCopyinClause *Clause =
|
|
new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setSourceExprs(SrcExprs);
|
|
Clause->setDestinationExprs(DstExprs);
|
|
Clause->setAssignmentOps(AssignmentOps);
|
|
return Clause;
|
|
}
|
|
|
|
OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
|
|
return new (Mem) OMPCopyinClause(N);
|
|
}
|
|
|
|
void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
|
|
assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
|
|
"not the same as the "
|
|
"preallocated buffer");
|
|
std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
|
|
}
|
|
|
|
void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
|
|
assert(DstExprs.size() == varlist_size() && "Number of destination "
|
|
"expressions is not the same as "
|
|
"the preallocated buffer");
|
|
std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
|
|
}
|
|
|
|
void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
|
|
assert(AssignmentOps.size() == varlist_size() &&
|
|
"Number of assignment expressions is not the same as the preallocated "
|
|
"buffer");
|
|
std::copy(AssignmentOps.begin(), AssignmentOps.end(),
|
|
getDestinationExprs().end());
|
|
}
|
|
|
|
OMPCopyprivateClause *OMPCopyprivateClause::Create(
|
|
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
|
|
SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
|
|
ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
|
|
OMPCopyprivateClause *Clause =
|
|
new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setSourceExprs(SrcExprs);
|
|
Clause->setDestinationExprs(DstExprs);
|
|
Clause->setAssignmentOps(AssignmentOps);
|
|
return Clause;
|
|
}
|
|
|
|
OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
|
|
unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
|
|
return new (Mem) OMPCopyprivateClause(N);
|
|
}
|
|
|
|
void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
|
|
assert(Privates.size() == varlist_size() &&
|
|
"Number of private copies is not the same as the preallocated buffer");
|
|
std::copy(Privates.begin(), Privates.end(), varlist_end());
|
|
}
|
|
|
|
void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
|
|
assert(
|
|
LHSExprs.size() == varlist_size() &&
|
|
"Number of LHS expressions is not the same as the preallocated buffer");
|
|
std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
|
|
}
|
|
|
|
void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
|
|
assert(
|
|
RHSExprs.size() == varlist_size() &&
|
|
"Number of RHS expressions is not the same as the preallocated buffer");
|
|
std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
|
|
}
|
|
|
|
void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
|
|
assert(ReductionOps.size() == varlist_size() && "Number of reduction "
|
|
"expressions is not the same "
|
|
"as the preallocated buffer");
|
|
std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
|
|
}
|
|
|
|
OMPReductionClause *OMPReductionClause::Create(
|
|
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
|
|
SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
|
|
NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
|
|
ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
|
|
ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
|
|
OMPReductionClause *Clause = new (Mem) OMPReductionClause(
|
|
StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
|
|
Clause->setVarRefs(VL);
|
|
Clause->setPrivates(Privates);
|
|
Clause->setLHSExprs(LHSExprs);
|
|
Clause->setRHSExprs(RHSExprs);
|
|
Clause->setReductionOps(ReductionOps);
|
|
return Clause;
|
|
}
|
|
|
|
OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
|
|
unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
|
|
return new (Mem) OMPReductionClause(N);
|
|
}
|
|
|
|
OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
|
|
SourceLocation StartLoc,
|
|
SourceLocation LParenLoc,
|
|
SourceLocation EndLoc,
|
|
ArrayRef<Expr *> VL) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
|
|
OMPFlushClause *Clause =
|
|
new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
return Clause;
|
|
}
|
|
|
|
OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
|
|
return new (Mem) OMPFlushClause(N);
|
|
}
|
|
|
|
OMPDependClause *
|
|
OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
|
|
SourceLocation LParenLoc, SourceLocation EndLoc,
|
|
OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
|
|
SourceLocation ColonLoc, ArrayRef<Expr *> VL) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
|
|
OMPDependClause *Clause =
|
|
new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setDependencyKind(DepKind);
|
|
Clause->setDependencyLoc(DepLoc);
|
|
Clause->setColonLoc(ColonLoc);
|
|
return Clause;
|
|
}
|
|
|
|
OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
|
|
return new (Mem) OMPDependClause(N);
|
|
}
|
|
|
|
OMPMapClause *OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc,
|
|
SourceLocation LParenLoc,
|
|
SourceLocation EndLoc, ArrayRef<Expr *> VL,
|
|
OpenMPMapClauseKind TypeModifier,
|
|
OpenMPMapClauseKind Type,
|
|
SourceLocation TypeLoc) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
|
|
OMPMapClause *Clause = new (Mem) OMPMapClause(
|
|
TypeModifier, Type, TypeLoc, StartLoc, LParenLoc, EndLoc, VL.size());
|
|
Clause->setVarRefs(VL);
|
|
Clause->setMapTypeModifier(TypeModifier);
|
|
Clause->setMapType(Type);
|
|
Clause->setMapLoc(TypeLoc);
|
|
return Clause;
|
|
}
|
|
|
|
OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned N) {
|
|
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
|
|
return new (Mem) OMPMapClause(N);
|
|
}
|