StmtOpenACC.h Source File (original) (raw)

13#ifndef LLVM_CLANG_AST_STMTOPENACC_H

14#define LLVM_CLANG_AST_STMTOPENACC_H

20#include

42protected:

46 : Stmt(SC), Kind(K), Range(Start, End), DirectiveLoc(DirectiveLoc) {}

51 assert(Clauses.empty() && "Cannot change clause list");

52 Clauses = NewClauses;

53 }

55public:

59 return S->getStmtClass() >= firstOpenACCConstructStmtConstant &&

60 S->getStmtClass() <= lastOpenACCConstructStmtConstant;

61 }

70 }

74 }

75};

84 Stmt *AssociatedStmt = nullptr;

86protected:

92 AssociatedStmt(AssocStmt) {}

99 }

100

101public:

103 return false;

104 }

105

108 return child_range(&AssociatedStmt, &AssociatedStmt + 1);

110 }

111

114 }

115};

116

117

118

119

120

121

122

123

124

125

126

127

130 private llvm::TrailingObjects<OpenACCComputeConstruct,

131 const OpenACCClause *> {

135 friend TrailingObjects;

140 nullptr) {

141

142

143

144 std::uninitialized_value_construct(

145 getTrailingObjects<const OpenACCClause *>(),

146 getTrailingObjects<const OpenACCClause *>() + NumClauses);

148 NumClauses));

149 }

150

154 Stmt *StructuredBlock)

156 DirectiveLoc, End, StructuredBlock) {

158 "Only parallel, serial, and kernels constructs should be "

159 "represented by this type");

160

161

162 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

163 getTrailingObjects<const OpenACCClause *>());

164

166 Clauses.size()));

167 }

168

170

171public:

173 return T->getStmtClass() == OpenACCComputeConstructClass;

174 }

175

177 unsigned NumClauses);

182

186 }

187};

188

189

190

193 private llvm::TrailingObjects<OpenACCLoopConstruct,

194 const OpenACCClause *> {

195

196

199

206 friend TrailingObjects;

207

209

213

214public:

216 return T->getStmtClass() == OpenACCLoopConstructClass;

217 }

218

220 unsigned NumClauses);

221

226

230 }

231

232

233

234

235

236

239 }

240

242 return ParentComputeConstructKind;

243 }

244};

245

246

247

250 private llvm::TrailingObjects<OpenACCCombinedConstruct,

251 const OpenACCClause *> {

252 friend TrailingObjects;

257 nullptr) {

258 std::uninitialized_value_construct(

259 getTrailingObjects<const OpenACCClause *>(),

260 getTrailingObjects<const OpenACCClause *>() + NumClauses);

262 NumClauses));

263 }

264

268 Stmt *StructuredBlock)

270 DirectiveLoc, End, StructuredBlock) {

272 "Only parallel loop, serial loop, and kernels loop constructs "

273 "should be represented by this type");

274

275 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

276 getTrailingObjects<const OpenACCClause *>());

278 Clauses.size()));

279 }

281

282public:

284 return T->getStmtClass() == OpenACCCombinedConstructClass;

285 }

286

288 unsigned NumClauses);

296 }

297};

298

299

300

303 private llvm::TrailingObjects<OpenACCDataConstruct,

304 const OpenACCClause *> {

305 friend TrailingObjects;

310 nullptr) {

311 std::uninitialized_value_construct(

312 getTrailingObjects<const OpenACCClause *>(),

313 getTrailingObjects<const OpenACCClause *>() + NumClauses);

315 NumClauses));

316 }

317

321 Stmt *StructuredBlock)

324 DirectiveLoc, End, StructuredBlock) {

325 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

326 getTrailingObjects<const OpenACCClause *>());

328 Clauses.size()));

329 }

331

332public:

334 return T->getStmtClass() == OpenACCDataConstructClass;

335 }

336

338 unsigned NumClauses);

343 Stmt *StructuredBlock);

347 }

348};

349

352 private llvm::TrailingObjects<OpenACCEnterDataConstruct,

353 const OpenACCClause *> {

354 friend TrailingObjects;

359 std::uninitialized_value_construct(

360 getTrailingObjects<const OpenACCClause *>(),

361 getTrailingObjects<const OpenACCClause *>() + NumClauses);

363 NumClauses));

364 }

370 DirectiveLoc, End) {

371 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

372 getTrailingObjects<const OpenACCClause *>());

374 Clauses.size()));

375 }

376

377public:

379 return T->getStmtClass() == OpenACCEnterDataConstructClass;

380 }

382 unsigned NumClauses);

386};

387

390 private llvm::TrailingObjects<OpenACCExitDataConstruct,

391 const OpenACCClause *> {

392 friend TrailingObjects;

397 std::uninitialized_value_construct(

398 getTrailingObjects<const OpenACCClause *>(),

399 getTrailingObjects<const OpenACCClause *>() + NumClauses);

401 NumClauses));

402 }

408 DirectiveLoc, End) {

409 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

410 getTrailingObjects<const OpenACCClause *>());

412 Clauses.size()));

413 }

414

415public:

417 return T->getStmtClass() == OpenACCExitDataConstructClass;

418 }

420 unsigned NumClauses);

424};

425

426

429 private llvm::TrailingObjects<OpenACCHostDataConstruct,

430 const OpenACCClause *> {

431 friend TrailingObjects;

436 nullptr) {

437 std::uninitialized_value_construct(

438 getTrailingObjects<const OpenACCClause *>(),

439 getTrailingObjects<const OpenACCClause *>() + NumClauses);

441 NumClauses));

442 }

446 Stmt *StructuredBlock)

449 DirectiveLoc, End, StructuredBlock) {

450 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

451 getTrailingObjects<const OpenACCClause *>());

453 Clauses.size()));

454 }

456

457public:

459 return T->getStmtClass() == OpenACCHostDataConstructClass;

460 }

462 unsigned NumClauses);

466 Stmt *StructuredBlock);

470 }

471};

472

473

474

477 private llvm::TrailingObjects<OpenACCWaitConstruct, Expr *,

478 OpenACCClause *> {

479

480

481

482

483 friend TrailingObjects;

486

487

489

491

492

493

494 unsigned NumExprs = 0;

495

500 NumExprs(NumExprs) {

501 assert(NumExprs >= 1 &&

502 "NumExprs should always be >= 1 because the 'devnum' "

503 "expr is represented by a null if necessary");

504 std::uninitialized_value_construct(getExprPtr(),

505 getExprPtr() + NumExprs);

506 std::uninitialized_value_construct(getTrailingObjects<OpenACCClause *>(),

507 getTrailingObjects<OpenACCClause *>() +

508 NumClauses);

510 getTrailingObjects<OpenACCClause *>()),

511 NumClauses));

512 }

513

521 End),

522 LParenLoc(LParenLoc), RParenLoc(RParenLoc), QueuesLoc(QueuesLoc),

523 NumExprs(QueueIdExprs.size() + 1) {

524 assert(NumExprs >= 1 &&

525 "NumExprs should always be >= 1 because the 'devnum' "

526 "expr is represented by a null if necessary");

527

528 std::uninitialized_copy(&DevNumExpr, &DevNumExpr + 1,

529 getExprPtr());

530 std::uninitialized_copy(QueueIdExprs.begin(), QueueIdExprs.end(),

531 getExprPtr() + 1);

532

533 std::uninitialized_copy(const_cast<OpenACCClause **>(Clauses.begin()),

535 getTrailingObjects<OpenACCClause *>());

537 getTrailingObjects<OpenACCClause *>()),

538 Clauses.size()));

539 }

540

541 size_t numTrailingObjects(OverloadToken<Expr *>) const { return NumExprs; }

542 size_t numTrailingObjects(OverloadToken<const OpenACCClause *>) const {

544 }

545

546 Expr **getExprPtr() const {

547 return const_cast<Expr**>(getTrailingObjects<Expr *>());

548 }

549

552 }

553

556 }

557

558public:

560 return T->getStmtClass() == OpenACCWaitConstructClass;

561 }

562

565

571

576

581 return getExprs().drop_front();

582 }

583

585 Stmt **Begin = reinterpret_cast<Stmt **>(getExprPtr());

587 }

588

591 reinterpret_cast<Stmt *const *>(getExprPtr());

593 }

594};

595

596

599 private llvm::TrailingObjects<OpenACCInitConstruct,

600 const OpenACCClause *> {

601 friend TrailingObjects;

606 std::uninitialized_value_construct(

607 getTrailingObjects<const OpenACCClause *>(),

608 getTrailingObjects<const OpenACCClause *>() + NumClauses);

610 NumClauses));

611 }

617 End) {

618 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

619 getTrailingObjects<const OpenACCClause *>());

621 Clauses.size()));

622 }

623

624public:

626 return T->getStmtClass() == OpenACCInitConstructClass;

627 }

629 unsigned NumClauses);

634};

635

636

639 private llvm::TrailingObjects<OpenACCShutdownConstruct,

640 const OpenACCClause *> {

641 friend TrailingObjects;

646 std::uninitialized_value_construct(

647 getTrailingObjects<const OpenACCClause *>(),

648 getTrailingObjects<const OpenACCClause *>() + NumClauses);

650 NumClauses));

651 }

657 DirectiveLoc, End) {

658 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

659 getTrailingObjects<const OpenACCClause *>());

661 Clauses.size()));

662 }

663

664public:

666 return T->getStmtClass() == OpenACCShutdownConstructClass;

667 }

669 unsigned NumClauses);

673};

674

675

678 private llvm::TrailingObjects<OpenACCSetConstruct,

679 const OpenACCClause *> {

680 friend TrailingObjects;

685 std::uninitialized_value_construct(

686 getTrailingObjects<const OpenACCClause *>(),

687 getTrailingObjects<const OpenACCClause *>() + NumClauses);

689 NumClauses));

690 }

691

697 End) {

698 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

699 getTrailingObjects<const OpenACCClause *>());

701 Clauses.size()));

702 }

703

704public:

706 return T->getStmtClass() == OpenACCSetConstructClass;

707 }

709 unsigned NumClauses);

714};

715

718 private llvm::TrailingObjects<OpenACCUpdateConstruct,

719 const OpenACCClause *> {

720 friend TrailingObjects;

725 std::uninitialized_value_construct(

726 getTrailingObjects<const OpenACCClause *>(),

727 getTrailingObjects<const OpenACCClause *>() + NumClauses);

729 NumClauses));

730 }

731

737 End) {

738 std::uninitialized_copy(Clauses.begin(), Clauses.end(),

739 getTrailingObjects<const OpenACCClause *>());

741 Clauses.size()));

742 }

743

744public:

746 return T->getStmtClass() == OpenACCUpdateConstructClass;

747 }

749 unsigned NumClauses);

753};

754}

755#endif

enum clang::sema::@1726::IndirectLocalPathEntry::EntryKind Kind

Defines some OpenACC-specific enums and functions.

Defines the clang::SourceLocation class and associated facilities.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

This represents one expression.

This is a base class for any OpenACC statement-level constructs that have an associated statement.

void setAssociatedStmt(Stmt *S)

Stmt * getAssociatedStmt()

const_child_range children() const

const Stmt * getAssociatedStmt() const

OpenACCAssociatedStmtConstruct(StmtClass SC, OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, Stmt *AssocStmt)

static bool classof(const Stmt *T)

This is the base type for all OpenACC Clauses.

static OpenACCCombinedConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

const Stmt * getLoop() const

This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...

static OpenACCComputeConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

Stmt * getStructuredBlock()

const Stmt * getStructuredBlock() const

This is the base class for an OpenACC statement-level construct, other construct types are expected t...

SourceLocation getEndLoc() const

SourceLocation getBeginLoc() const

OpenACCDirectiveKind getDirectiveKind() const

void setClauseList(MutableArrayRef< const OpenACCClause * > NewClauses)

ArrayRef< const OpenACCClause * > clauses() const

const_child_range children() const

SourceLocation getDirectiveLoc() const

static bool classof(const Stmt *S)

OpenACCConstructStmt(StmtClass SC, OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End)

const Stmt * getStructuredBlock() const

static OpenACCDataConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

Stmt * getStructuredBlock()

static bool classof(const Stmt *T)

static OpenACCEnterDataConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

static OpenACCExitDataConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static OpenACCHostDataConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

Stmt * getStructuredBlock()

static bool classof(const Stmt *T)

const Stmt * getStructuredBlock() const

static bool classof(const Stmt *T)

static OpenACCInitConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

This class represents a 'loop' construct.

static OpenACCLoopConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

OpenACCDirectiveKind getParentComputeConstructKind() const

const Stmt * getLoop() const

bool isOrphanedLoopConstruct() const

OpenACC 3.3 2.9: An orphaned loop construct is a loop construct that is not lexically enclosed within...

static bool classof(const Stmt *T)

static OpenACCSetConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

static OpenACCShutdownConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

static bool classof(const Stmt *T)

static OpenACCUpdateConstruct * CreateEmpty(const ASTContext &C, unsigned NumClauses)

llvm::ArrayRef< Expr * > getQueueIdExprs()

static bool classof(const Stmt *T)

SourceLocation getRParenLoc() const

bool hasDevNumExpr() const

static OpenACCWaitConstruct * CreateEmpty(const ASTContext &C, unsigned NumExprs, unsigned NumClauses)

llvm::ArrayRef< Expr * > getQueueIdExprs() const

SourceLocation getQueuesLoc() const

const_child_range children() const

bool hasQueuesTag() const

SourceLocation getLParenLoc() const

Expr * getDevNumExpr() const

A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...

Encodes a location in the source.

A trivial tuple used to represent a source range.

Stmt - This represents one statement.

StmtIterator child_iterator

Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatem...

llvm::iterator_range< child_iterator > child_range

llvm::iterator_range< const_child_iterator > const_child_range

The JSON file list parser is used to communicate input to InstallAPI.

bool isOpenACCComputeDirectiveKind(OpenACCDirectiveKind K)

bool isOpenACCCombinedDirectiveKind(OpenACCDirectiveKind K)

@ Create

'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

const FunctionProtoType * T