forked from OSchip/llvm-project
Move functions declared in Stmt{ObjC,CXX}.h and OpenMPClause.h into
their associated .cpp file. Previous refactorings long long ago had split out the above categories of classes from Stmt.h into their own header files, but failed to also split the Stmt.cpp implementation file similarly. Do so for readability's sake. llvm-svn: 249131
This commit is contained in:
James Y Knight
parent
ea2f90c96b
commit
b8bfd96a10
|
|
@ -40,13 +40,17 @@ add_clang_library(clangAST
|
|||
MicrosoftMangle.cpp
|
||||
NestedNameSpecifier.cpp
|
||||
NSAPI.cpp
|
||||
OpenMPClause.cpp
|
||||
ParentMap.cpp
|
||||
RawCommentList.cpp
|
||||
RecordLayout.cpp
|
||||
RecordLayoutBuilder.cpp
|
||||
SelectorLocationsKind.cpp
|
||||
Stmt.cpp
|
||||
StmtCXX.cpp
|
||||
StmtIterator.cpp
|
||||
StmtObjC.cpp
|
||||
StmtOpenMP.cpp
|
||||
StmtPrinter.cpp
|
||||
StmtProfile.cpp
|
||||
StmtViz.cpp
|
||||
|
|
|
|||
|
|
@ -0,0 +1,433 @@
|
|||
//===--- 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(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
2 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
2 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
3 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
3 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
5 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
5 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
(5 * VL.size() + 2) * sizeof(Expr *));
|
||||
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(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
(5 * NumVars + 2) * sizeof(Expr *));
|
||||
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(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * N);
|
||||
return new (Mem) OMPCopyprivateClause(N);
|
||||
}
|
||||
|
||||
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(), varlist_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 *> LHSExprs, ArrayRef<Expr *> RHSExprs,
|
||||
ArrayRef<Expr *> ReductionOps) {
|
||||
void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * VL.size());
|
||||
OMPReductionClause *Clause = new (Mem) OMPReductionClause(
|
||||
StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
|
||||
Clause->setVarRefs(VL);
|
||||
Clause->setLHSExprs(LHSExprs);
|
||||
Clause->setRHSExprs(RHSExprs);
|
||||
Clause->setReductionOps(ReductionOps);
|
||||
return Clause;
|
||||
}
|
||||
|
||||
OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
|
||||
unsigned N) {
|
||||
void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
4 * sizeof(Expr *) * 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(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPDependClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(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(llvm::RoundUpToAlignment(sizeof(OMPDependClause),
|
||||
llvm::alignOf<Expr *>()) +
|
||||
sizeof(Expr *) * N);
|
||||
return new (Mem) OMPDependClause(N);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,84 @@
|
|||
//===--- StmtCXX.cpp - Classes for representing C++ statements ------------===//
|
||||
//
|
||||
// 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 StmtCXX.h
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/AST/StmtCXX.h"
|
||||
|
||||
#include "clang/AST/ASTContext.h"
|
||||
|
||||
using namespace clang;
|
||||
|
||||
QualType CXXCatchStmt::getCaughtType() const {
|
||||
if (ExceptionDecl)
|
||||
return ExceptionDecl->getType();
|
||||
return QualType();
|
||||
}
|
||||
|
||||
CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, SourceLocation tryLoc,
|
||||
Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
|
||||
std::size_t Size = sizeof(CXXTryStmt);
|
||||
Size += ((handlers.size() + 1) * sizeof(Stmt *));
|
||||
|
||||
void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
|
||||
return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
|
||||
}
|
||||
|
||||
CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty,
|
||||
unsigned numHandlers) {
|
||||
std::size_t Size = sizeof(CXXTryStmt);
|
||||
Size += ((numHandlers + 1) * sizeof(Stmt *));
|
||||
|
||||
void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
|
||||
return new (Mem) CXXTryStmt(Empty, numHandlers);
|
||||
}
|
||||
|
||||
CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
|
||||
ArrayRef<Stmt *> handlers)
|
||||
: Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
|
||||
Stmt **Stmts = reinterpret_cast<Stmt **>(this + 1);
|
||||
Stmts[0] = tryBlock;
|
||||
std::copy(handlers.begin(), handlers.end(), Stmts + 1);
|
||||
}
|
||||
|
||||
CXXForRangeStmt::CXXForRangeStmt(DeclStmt *Range, DeclStmt *BeginEndStmt,
|
||||
Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
|
||||
Stmt *Body, SourceLocation FL,
|
||||
SourceLocation CL, SourceLocation RPL)
|
||||
: Stmt(CXXForRangeStmtClass), ForLoc(FL), ColonLoc(CL), RParenLoc(RPL) {
|
||||
SubExprs[RANGE] = Range;
|
||||
SubExprs[BEGINEND] = BeginEndStmt;
|
||||
SubExprs[COND] = Cond;
|
||||
SubExprs[INC] = Inc;
|
||||
SubExprs[LOOPVAR] = LoopVar;
|
||||
SubExprs[BODY] = Body;
|
||||
}
|
||||
|
||||
Expr *CXXForRangeStmt::getRangeInit() {
|
||||
DeclStmt *RangeStmt = getRangeStmt();
|
||||
VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
|
||||
assert(RangeDecl && "for-range should have a single var decl");
|
||||
return RangeDecl->getInit();
|
||||
}
|
||||
|
||||
const Expr *CXXForRangeStmt::getRangeInit() const {
|
||||
return const_cast<CXXForRangeStmt *>(this)->getRangeInit();
|
||||
}
|
||||
|
||||
VarDecl *CXXForRangeStmt::getLoopVariable() {
|
||||
Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
|
||||
assert(LV && "No loop variable in CXXForRangeStmt");
|
||||
return cast<VarDecl>(LV);
|
||||
}
|
||||
|
||||
const VarDecl *CXXForRangeStmt::getLoopVariable() const {
|
||||
return const_cast<CXXForRangeStmt *>(this)->getLoopVariable();
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
//===--- StmtObjC.cpp - Classes for representing ObjC statements ---------===//
|
||||
//
|
||||
// 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 StmtObjC.h
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/AST/StmtObjC.h"
|
||||
|
||||
#include "clang/AST/Expr.h"
|
||||
#include "clang/AST/ASTContext.h"
|
||||
|
||||
using namespace clang;
|
||||
|
||||
ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
|
||||
Stmt *Body, SourceLocation FCL,
|
||||
SourceLocation RPL)
|
||||
: Stmt(ObjCForCollectionStmtClass) {
|
||||
SubExprs[ELEM] = Elem;
|
||||
SubExprs[COLLECTION] = Collect;
|
||||
SubExprs[BODY] = Body;
|
||||
ForLoc = FCL;
|
||||
RParenLoc = RPL;
|
||||
}
|
||||
|
||||
ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
|
||||
Stmt **CatchStmts, unsigned NumCatchStmts,
|
||||
Stmt *atFinallyStmt)
|
||||
: Stmt(ObjCAtTryStmtClass), AtTryLoc(atTryLoc),
|
||||
NumCatchStmts(NumCatchStmts), HasFinally(atFinallyStmt != nullptr) {
|
||||
Stmt **Stmts = getStmts();
|
||||
Stmts[0] = atTryStmt;
|
||||
for (unsigned I = 0; I != NumCatchStmts; ++I)
|
||||
Stmts[I + 1] = CatchStmts[I];
|
||||
|
||||
if (HasFinally)
|
||||
Stmts[NumCatchStmts + 1] = atFinallyStmt;
|
||||
}
|
||||
|
||||
ObjCAtTryStmt *ObjCAtTryStmt::Create(const ASTContext &Context,
|
||||
SourceLocation atTryLoc, Stmt *atTryStmt,
|
||||
Stmt **CatchStmts, unsigned NumCatchStmts,
|
||||
Stmt *atFinallyStmt) {
|
||||
unsigned Size =
|
||||
sizeof(ObjCAtTryStmt) +
|
||||
(1 + NumCatchStmts + (atFinallyStmt != nullptr)) * sizeof(Stmt *);
|
||||
void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
|
||||
return new (Mem) ObjCAtTryStmt(atTryLoc, atTryStmt, CatchStmts, NumCatchStmts,
|
||||
atFinallyStmt);
|
||||
}
|
||||
|
||||
ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(const ASTContext &Context,
|
||||
unsigned NumCatchStmts,
|
||||
bool HasFinally) {
|
||||
unsigned Size =
|
||||
sizeof(ObjCAtTryStmt) + (1 + NumCatchStmts + HasFinally) * sizeof(Stmt *);
|
||||
void *Mem = Context.Allocate(Size, llvm::alignOf<ObjCAtTryStmt>());
|
||||
return new (Mem) ObjCAtTryStmt(EmptyShell(), NumCatchStmts, HasFinally);
|
||||
}
|
||||
|
||||
SourceLocation ObjCAtTryStmt::getLocEnd() const {
|
||||
if (HasFinally)
|
||||
return getFinallyStmt()->getLocEnd();
|
||||
if (NumCatchStmts)
|
||||
return getCatchStmt(NumCatchStmts - 1)->getLocEnd();
|
||||
return getTryBody()->getLocEnd();
|
||||
}
|
||||
|
|
@ -0,0 +1,740 @@
|
|||
//===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
|
||||
//
|
||||
// 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 StmtOpenMP.h
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/AST/StmtOpenMP.h"
|
||||
|
||||
#include "clang/AST/ASTContext.h"
|
||||
|
||||
using namespace clang;
|
||||
|
||||
void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
|
||||
assert(Clauses.size() == getNumClauses() &&
|
||||
"Number of clauses is not the same as the preallocated buffer");
|
||||
std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
|
||||
}
|
||||
|
||||
void OMPLoopDirective::setCounters(ArrayRef<Expr *> 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<Expr *> 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<Expr *> 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<Expr *> 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<Expr *> 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());
|
||||
}
|
||||
|
||||
OMPParallelDirective *OMPParallelDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPParallelDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
|
||||
llvm::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);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum,
|
||||
EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
|
||||
llvm::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->setCounters(Exprs.Counters);
|
||||
Dir->setPrivateCounters(Exprs.PrivateCounters);
|
||||
Dir->setInits(Exprs.Inits);
|
||||
Dir->setUpdates(Exprs.Updates);
|
||||
Dir->setFinals(Exprs.Finals);
|
||||
Dir->setHasCancel(HasCancel);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum,
|
||||
EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
|
||||
llvm::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->setCounters(Exprs.Counters);
|
||||
Dir->setPrivateCounters(Exprs.PrivateCounters);
|
||||
Dir->setInits(Exprs.Inits);
|
||||
Dir->setUpdates(Exprs.Updates);
|
||||
Dir->setFinals(Exprs.Finals);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum,
|
||||
EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPSectionsDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPSectionDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPSectionDirective),
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size + sizeof(Stmt *));
|
||||
return new (Mem) OMPSectionDirective();
|
||||
}
|
||||
|
||||
OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
|
||||
SourceLocation StartLoc,
|
||||
SourceLocation EndLoc,
|
||||
ArrayRef<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPSingleDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPMasterDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPMasterDirective),
|
||||
llvm::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, Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size + sizeof(Stmt *));
|
||||
OMPCriticalDirective *Dir =
|
||||
new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc);
|
||||
Dir->setAssociatedStmt(AssociatedStmt);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
|
||||
EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size + sizeof(Stmt *));
|
||||
return new (Mem) OMPCriticalDirective();
|
||||
}
|
||||
|
||||
OMPParallelForDirective *OMPParallelForDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
|
||||
llvm::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->setCounters(Exprs.Counters);
|
||||
Dir->setPrivateCounters(Exprs.PrivateCounters);
|
||||
Dir->setInits(Exprs.Inits);
|
||||
Dir->setUpdates(Exprs.Updates);
|
||||
Dir->setFinals(Exprs.Finals);
|
||||
Dir->setHasCancel(HasCancel);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPParallelForDirective *
|
||||
OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
|
||||
unsigned CollapsedNum, EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
|
||||
llvm::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->setCounters(Exprs.Counters);
|
||||
Dir->setPrivateCounters(Exprs.PrivateCounters);
|
||||
Dir->setInits(Exprs.Inits);
|
||||
Dir->setUpdates(Exprs.Updates);
|
||||
Dir->setFinals(Exprs.Finals);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPParallelForSimdDirective *
|
||||
OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum, EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
|
||||
llvm::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<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt, bool HasCancel) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPTaskDirective),
|
||||
llvm::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,
|
||||
Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size + sizeof(Stmt *));
|
||||
OMPTaskgroupDirective *Dir =
|
||||
new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
|
||||
Dir->setAssociatedStmt(AssociatedStmt);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
|
||||
EmptyShell) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size + sizeof(Stmt *));
|
||||
return new (Mem) OMPTaskgroupDirective();
|
||||
}
|
||||
|
||||
OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
OpenMPDirectiveKind CancelRegion) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(
|
||||
sizeof(OMPCancellationPointDirective), llvm::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::RoundUpToAlignment(
|
||||
sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size);
|
||||
return new (Mem) OMPCancellationPointDirective();
|
||||
}
|
||||
|
||||
OMPCancelDirective *
|
||||
OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
|
||||
SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
|
||||
OpenMPDirectiveKind CancelRegion) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(
|
||||
sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPCancelDirective) +
|
||||
sizeof(OMPClause *) * NumClauses,
|
||||
llvm::alignOf<Stmt *>());
|
||||
void *Mem = C.Allocate(Size);
|
||||
return new (Mem) OMPCancelDirective(NumClauses);
|
||||
}
|
||||
|
||||
OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
|
||||
SourceLocation StartLoc,
|
||||
SourceLocation EndLoc,
|
||||
ArrayRef<OMPClause *> Clauses) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPFlushDirective),
|
||||
llvm::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<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPOrderedDirective),
|
||||
llvm::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<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
|
||||
Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPAtomicDirective),
|
||||
llvm::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<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPTargetDirective),
|
||||
llvm::alignOf<OMPClause *>());
|
||||
void *Mem =
|
||||
C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
|
||||
return new (Mem) OMPTargetDirective(NumClauses);
|
||||
}
|
||||
|
||||
OMPTargetDataDirective *OMPTargetDataDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
|
||||
void *Mem =
|
||||
C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
|
||||
llvm::alignOf<OMPClause *>()) +
|
||||
sizeof(OMPClause *) * N + sizeof(Stmt *));
|
||||
return new (Mem) OMPTargetDataDirective(N);
|
||||
}
|
||||
|
||||
OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
|
||||
SourceLocation StartLoc,
|
||||
SourceLocation EndLoc,
|
||||
ArrayRef<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt) {
|
||||
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
|
||||
llvm::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::RoundUpToAlignment(sizeof(OMPTeamsDirective),
|
||||
llvm::alignOf<OMPClause *>());
|
||||
void *Mem =
|
||||
C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
|
||||
return new (Mem) OMPTeamsDirective(NumClauses);
|
||||
}
|
||||
Loading…
Reference in New Issue