OpenACCClause.h Source File (original) (raw)

14#ifndef LLVM_CLANG_AST_OPENACCCLAUSE_H

15#define LLVM_CLANG_AST_OPENACCCLAUSE_H

20#include

28protected:

31 : Kind(K), Location(BeginLoc, EndLoc) {

33 "Begin and end location must be valid for OpenACCClause");

34 }

36public:

45 using child_range = llvm::iterator_range<child_iterator>;

52 }

55};

59protected:

63public:

66 }

73 }

76 }

77};

81protected:

85public:

88 }

95 }

98 }

99};

100

101

103protected:

106

107public:

110 }

111

114

117 }

120 }

121};

122

123

125protected:

128

129public:

132 }

133

136

139 }

142 }

143};

144

146protected:

149

150public:

153 }

154

157

160 }

163 }

164};

165

166

168

170

171protected:

174 : OpenACCClause(K, BeginLoc, EndLoc), LParenLoc(LParenLoc) {}

175

176public:

178

180

183 }

186 }

187};

188

190

191

194 private llvm::TrailingObjects<OpenACCDeviceTypeClause,

195 DeviceTypeArgument> {

196 friend TrailingObjects;

197

198

199 unsigned NumArchs;

205 NumArchs(Archs.size()) {

206 assert(

208 "Invalid clause kind for device-type");

209

211 return Arg.second.isInvalid();

212 }) && "Invalid SourceLocation for an argument");

213

214 assert(

215 (Archs.size() == 1 || !llvm::any_of(Archs,

217 return Arg.first == nullptr;

218 })) &&

219 "Only a single asterisk version is permitted, and must be the "

220 "only one");

221

222 std::uninitialized_copy(Archs.begin(), Archs.end(),

223 getTrailingObjects());

224 }

225

226public:

230 }

234 }

235

238 getTrailingObjects(), NumArchs);

239 }

240

245};

246

247

251

253

254protected:

258 EndLoc),

259 DefaultClauseKind(K) {

262 "Invalid Clause Kind");

263 }

264

265public:

268 }

270 return DefaultClauseKind;

271 }

272

278};

279

280

281

283 Expr *ConditionExpr = nullptr;

284

285protected:

290 ConditionExpr(ConditionExpr) {}

291

292public:

294

298

300 if (ConditionExpr)

301 return child_range(reinterpret_cast<Stmt **>(&ConditionExpr),

302 reinterpret_cast<Stmt **>(&ConditionExpr + 1));

304 }

305

307 if (ConditionExpr)

309 reinterpret_cast<Stmt *const *>(&ConditionExpr),

310 reinterpret_cast<Stmt *const *>(&ConditionExpr + 1));

312 }

313};

314

315

317protected:

320

321public:

324 }

328};

329

330

331

334 private llvm::TrailingObjects<OpenACCSelfClause, Expr *> {

335 friend TrailingObjects;

336

337

338 std::optional HasConditionExpr;

339

340

341

342 unsigned NumExprs;

343

348

349

350

352 return {getTrailingObjects<Expr *>(), NumExprs};

353 }

354

355public:

358 }

359

361

363 assert(HasConditionExpr.has_value() &&

364 "VarList Self Clause asked about condition expression");

365 return *HasConditionExpr;

366 }

367

369 assert(HasConditionExpr.has_value() &&

370 "VarList Self Clause asked about condition expression");

371 assert(getExprs().size() == 1 &&

372 "ConditionExpr Self Clause with too many Exprs");

373 return getExprs()[0];

374 }

375

377 assert(HasConditionExpr.has_value() &&

378 "VarList Self Clause asked about condition expression");

379 assert(getExprs().size() == 1 &&

380 "ConditionExpr Self Clause with too many Exprs");

381 return getExprs()[0];

382 }

383

385 assert(!HasConditionExpr.has_value() &&

386 "Condition Expr self clause asked about var list");

387 return getExprs();

388 }

390 assert(!HasConditionExpr.has_value() &&

391 "Condition Expr self clause asked about var list");

392 return getExprs();

393 }

394

397 reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>()),

398 reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>() + NumExprs));

399 }

400

404 }

405

413};

414

415

418

419protected:

423

424

425

427 assert(Exprs.empty() && "Cannot change Exprs list");

428 Exprs = NewExprs;

429 }

430

431

432

434

435public:

438 return child_range(reinterpret_cast<Stmt **>(Exprs.begin()),

439 reinterpret_cast<Stmt **>(Exprs.end()));

440 }

441

446 }

447};

448

449

452 private llvm::TrailingObjects<OpenACCWaitClause, Expr *> {

453 friend TrailingObjects;

459 EndLoc),

460 QueuesLoc(QueuesLoc) {

461

462

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

464 getTrailingObjects<Expr *>());

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

466 getTrailingObjects<Expr *>() + 1);

468 MutableArrayRef(getTrailingObjects<Expr *>(), QueueIdExprs.size() + 1));

469 }

470

471public:

474 }

480

487 }

490 }

491};

492

495 private llvm::TrailingObjects<OpenACCNumGangsClause, Expr *> {

496 friend TrailingObjects;

497

501 EndLoc) {

502 std::uninitialized_copy(IntExprs.begin(), IntExprs.end(),

503 getTrailingObjects<Expr *>());

505 }

506

507public:

510 }

514

517 }

518

521 }

522};

523

526 private llvm::TrailingObjects<OpenACCTileClause, Expr *> {

527 friend TrailingObjects;

531 EndLoc) {

532 std::uninitialized_copy(SizeExprs.begin(), SizeExprs.end(),

533 getTrailingObjects<Expr *>());

535 }

536

537public:

540 }

547 }

548

551 }

552};

553

554

555

557 Expr *IntExpr;

558

559protected:

564 IntExpr(IntExpr) {

565 if (IntExpr)

567 }

568

569public:

574 }

575

577};

578

581 private llvm::TrailingObjects<OpenACCGangClause, Expr *, OpenACCGangKind> {

582 friend TrailingObjects;

583protected:

587

589 return getTrailingObjects()[I];

590 }

591

592public:

595 }

596

599 }

600

602 std::pair<OpenACCGangKind, const Expr *> getExpr(unsigned I) const {

604 }

605

607 for (unsigned I = 0; I < getNumExprs(); ++I) {

609 return true;

610 }

611 return false;

612 }

613

618};

619

621protected:

624

625public:

628 }

629

634};

635

637protected:

640

641public:

644 }

645

650};

651

655

656public:

659 }

664};

665

669

670public:

673 }

677};

678

682

683public:

686 }

691};

692

696

697public:

700 }

705};

706

710

711public:

714 }

718};

719

720

721

722

723

725 bool HasForce = false;

726

729

730public:

733

734 bool hasForce() const { return HasForce; }

735

738 }

739

744};

745

746

747

748

749

751protected:

755

756public:

760};

761

764 private llvm::TrailingObjects<OpenACCPrivateClause, Expr *> {

765 friend TrailingObjects;

766

770 LParenLoc, EndLoc) {

771 std::uninitialized_copy(VarList.begin(), VarList.end(),

772 getTrailingObjects<Expr *>());

774 }

775

776public:

779 }

783};

784

787 private llvm::TrailingObjects<OpenACCFirstPrivateClause, Expr *> {

788 friend TrailingObjects;

789

793 LParenLoc, EndLoc) {

794 std::uninitialized_copy(VarList.begin(), VarList.end(),

795 getTrailingObjects<Expr *>());

797 }

798

799public:

802 }

806};

807

810 private llvm::TrailingObjects<OpenACCDevicePtrClause, Expr *> {

811 friend TrailingObjects;

812

816 LParenLoc, EndLoc) {

817 std::uninitialized_copy(VarList.begin(), VarList.end(),

818 getTrailingObjects<Expr *>());

820 }

821

822public:

825 }

829};

830

833 private llvm::TrailingObjects<OpenACCAttachClause, Expr *> {

834 friend TrailingObjects;

835

839 EndLoc) {

840 std::uninitialized_copy(VarList.begin(), VarList.end(),

841 getTrailingObjects<Expr *>());

843 }

844

845public:

848 }

852};

853

856 private llvm::TrailingObjects<OpenACCDetachClause, Expr *> {

857 friend TrailingObjects;

858

862 EndLoc) {

863 std::uninitialized_copy(VarList.begin(), VarList.end(),

864 getTrailingObjects<Expr *>());

866 }

867

868public:

871 }

875};

876

879 private llvm::TrailingObjects<OpenACCDeleteClause, Expr *> {

880 friend TrailingObjects;

881

885 EndLoc) {

886 std::uninitialized_copy(VarList.begin(), VarList.end(),

887 getTrailingObjects<Expr *>());

889 }

890

891public:

894 }

898};

899

902 private llvm::TrailingObjects<OpenACCUseDeviceClause, Expr *> {

903 friend TrailingObjects;

904

908 LParenLoc, EndLoc) {

909 std::uninitialized_copy(VarList.begin(), VarList.end(),

910 getTrailingObjects<Expr *>());

912 }

913

914public:

917 }

921};

922

925 private llvm::TrailingObjects<OpenACCNoCreateClause, Expr *> {

926 friend TrailingObjects;

927

931 LParenLoc, EndLoc) {

932 std::uninitialized_copy(VarList.begin(), VarList.end(),

933 getTrailingObjects<Expr *>());

935 }

936

937public:

940 }

944};

945

948 private llvm::TrailingObjects<OpenACCPresentClause, Expr *> {

949 friend TrailingObjects;

950

954 LParenLoc, EndLoc) {

955 std::uninitialized_copy(VarList.begin(), VarList.end(),

956 getTrailingObjects<Expr *>());

958 }

959

960public:

963 }

967};

970 private llvm::TrailingObjects<OpenACCHostClause, Expr *> {

971 friend TrailingObjects;

972

976 EndLoc) {

977 std::uninitialized_copy(VarList.begin(), VarList.end(),

978 getTrailingObjects<Expr *>());

980 }

981

982public:

985 }

990};

991

994 private llvm::TrailingObjects<OpenACCDeviceClause, Expr *> {

995 friend TrailingObjects;

996

1000 EndLoc) {

1001 std::uninitialized_copy(VarList.begin(), VarList.end(),

1002 getTrailingObjects<Expr *>());

1004 }

1005

1006public:

1009 }

1013};

1014

1017 private llvm::TrailingObjects<OpenACCCopyClause, Expr *> {

1018 friend TrailingObjects;

1019

1027 "Invalid clause kind for copy-clause");

1028 std::uninitialized_copy(VarList.begin(), VarList.end(),

1029 getTrailingObjects<Expr *>());

1031 }

1032

1033public:

1038 }

1043};

1044

1047 private llvm::TrailingObjects<OpenACCCopyInClause, Expr *> {

1048 friend TrailingObjects;

1049 bool IsReadOnly;

1050

1055 IsReadOnly(IsReadOnly) {

1059 "Invalid clause kind for copyin-clause");

1060 std::uninitialized_copy(VarList.begin(), VarList.end(),

1061 getTrailingObjects<Expr *>());

1063 }

1064

1065public:

1070 }

1076};

1077

1080 private llvm::TrailingObjects<OpenACCCopyOutClause, Expr *> {

1081 friend TrailingObjects;

1082 bool IsZero;

1083

1088 IsZero(IsZero) {

1092 "Invalid clause kind for copyout-clause");

1093 std::uninitialized_copy(VarList.begin(), VarList.end(),

1094 getTrailingObjects<Expr *>());

1096 }

1097

1098public:

1103 }

1104 bool isZero() const { return IsZero; }

1109};

1110

1113 private llvm::TrailingObjects<OpenACCCreateClause, Expr *> {

1114 friend TrailingObjects;

1115 bool IsZero;

1116

1121 IsZero(IsZero) {

1125 "Invalid clause kind for create-clause");

1126 std::uninitialized_copy(VarList.begin(), VarList.end(),

1127 getTrailingObjects<Expr *>());

1129 }

1130

1131public:

1136 }

1137 bool isZero() const { return IsZero; }

1142};

1143

1146 private llvm::TrailingObjects<OpenACCReductionClause, Expr *> {

1147 friend TrailingObjects;

1149

1154 LParenLoc, EndLoc),

1155 Op(Operator) {

1156 std::uninitialized_copy(VarList.begin(), VarList.end(),

1157 getTrailingObjects<Expr *>());

1159 }

1160

1161public:

1164 }

1165

1170

1172};

1173

1175 Impl &getDerived() { return static_cast<Impl &>(*this); }

1176

1177public:

1181 }

1182

1184 if ()

1185 return;

1186

1187 switch (C->getClauseKind()) {

1188#define VISIT_CLAUSE(CLAUSE_NAME) \

1189 case OpenACCClauseKind::CLAUSE_NAME: \

1190 Visit##CLAUSE_NAME##Clause(*cast<OpenACC##CLAUSE_NAME##Clause>(C)); \

1191 return;

1192#define CLAUSE_ALIAS(ALIAS_NAME, CLAUSE_NAME, DEPRECATED) \

1193 case OpenACCClauseKind::ALIAS_NAME: \

1194 Visit##CLAUSE_NAME##Clause(*cast<OpenACC##CLAUSE_NAME##Clause>(C)); \

1195 return;

1196#include "clang/Basic/OpenACCClauses.def"

1197

1198 default:

1199 llvm_unreachable("Clause visitor not yet implemented");

1200 }

1201 llvm_unreachable("Invalid Clause kind");

1202 }

1203

1204#define VISIT_CLAUSE(CLAUSE_NAME) \

1205 void Visit##CLAUSE_NAME##Clause( \

1206 const OpenACC##CLAUSE_NAME##Clause &Clause) { \

1207 return getDerived().Visit##CLAUSE_NAME##Clause(Clause); \

1208 }

1209

1210#include "clang/Basic/OpenACCClauses.def"

1211};

1212

1215 raw_ostream &OS;

1217

1218 void printExpr(const Expr *E);

1219

1220public:

1224

1225 if (Clause != List.back())

1226 OS << ' ';

1227 }

1228 }

1230 : OS(OS), Policy(Policy) {}

1231

1232#define VISIT_CLAUSE(CLAUSE_NAME) \

1233 void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);

1234#include "clang/Basic/OpenACCClauses.def"

1235};

1236

1237}

1238

1239#endif

Defines the clang::ASTContext interface.

Defines some OpenACC-specific enums and functions.

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

This represents one expression.

static bool classof(const OpenACCClause *C)

const_child_range children() const

OpenACCAutoClause(SourceLocation BeginLoc, SourceLocation EndLoc)

static bool classof(const OpenACCClause *C)

OpenACCClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)

void VisitClauseList(ArrayRef< const OpenACCClause * > List)

void Visit(const OpenACCClause *C)

void VisitClauseList(ArrayRef< const OpenACCClause * > List)

Represents one of the handful of classes that has an optional/required 'condition' expression as an a...

static bool classof(const OpenACCClause *C)

bool hasConditionExpr() const

const Expr * getConditionExpr() const

Expr * getConditionExpr()

OpenACCClauseWithCondition(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)

const_child_range children() const

Represents a clause that has one or more expressions associated with it.

static bool classof(const OpenACCClause *C)

OpenACCClauseWithExprs(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

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

Gets the entire list of expressions, but leave it to the individual clauses to expose this how they'd...

const_child_range children() const

void setExprs(MutableArrayRef< Expr * > NewExprs)

Used only for initialization, the leaf class can initialize this to trailing storage.

Represents a clause that has a list of parameters.

SourceLocation getLParenLoc() const

static bool classof(const OpenACCClause *C)

OpenACCClauseWithParams(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

const_child_range children() const

Represents one of a handful of clauses that have a single integer expression.

OpenACCClauseWithSingleIntExpr(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)

const Expr * getIntExpr() const

static bool classof(const OpenACCClause *C)

Represents a clause with one or more 'var' objects, represented as an expr, as its arguments.

OpenACCClauseWithVarList(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

static bool classof(const OpenACCClause *C)

ArrayRef< Expr * > getVarList()

ArrayRef< Expr * > getVarList() const

This is the base type for all OpenACC Clauses.

StmtIterator child_iterator

OpenACCClauseKind getClauseKind() const

SourceLocation getBeginLoc() const

const_child_range children() const

static bool classof(const OpenACCClause *)

llvm::iterator_range< child_iterator > child_range

ConstStmtIterator const_child_iterator

OpenACCClause(OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation EndLoc)

virtual ~OpenACCClause()=default

llvm::iterator_range< const_child_iterator > const_child_range

SourceLocation getEndLoc() const

Represents a 'collapse' clause on a 'loop' construct.

const Expr * getLoopCount() const

static bool classof(const OpenACCClause *C)

A 'default' clause, has the optional 'none' or 'present' argument.

OpenACCDefaultClause(OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

friend class ASTWriterStmt

OpenACCDefaultClauseKind getDefaultClauseKind() const

static bool classof(const OpenACCClause *C)

friend class ASTReaderStmt

static bool classof(const OpenACCClause *C)

A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or an identifier.

ArrayRef< DeviceTypeArgument > getArchitectures() const

static bool classof(const OpenACCClause *C)

OpenACCFinalizeClause(SourceLocation BeginLoc, SourceLocation EndLoc)

static bool classof(const OpenACCClause *C)

const_child_range children() const

static bool classof(const OpenACCClause *C)

OpenACCGangKind getGangKind(unsigned I) const

bool hasExprOfKind(OpenACCGangKind GK) const

size_t numTrailingObjects(OverloadToken< Expr * >) const

static bool classof(const OpenACCClause *C)

unsigned getNumExprs() const

std::pair< OpenACCGangKind, const Expr * > getExpr(unsigned I) const

static bool classof(const OpenACCClause *C)

An 'if' clause, which has a required condition expression.

static bool classof(const OpenACCClause *C)

const_child_range children() const

OpenACCIfPresentClause(SourceLocation BeginLoc, SourceLocation EndLoc)

OpenACCIndependentClause(SourceLocation BeginLoc, SourceLocation EndLoc)

static bool classof(const OpenACCClause *C)

const_child_range children() const

static bool classof(const OpenACCClause *C)

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

llvm::ArrayRef< Expr * > getIntExprs()

static bool classof(const OpenACCClause *C)

OpenACCReductionOperator getReductionOp() const

A 'self' clause, which has an optional condition expression, or, in the event of an 'update' directiv...

Expr * getConditionExpr()

const Expr * getConditionExpr() const

bool isConditionExprClause() const

const_child_range children() const

static bool classof(const OpenACCClause *C)

ArrayRef< Expr * > getVarList()

bool hasConditionExpr() const

ArrayRef< Expr * > getVarList() const

static bool classof(const OpenACCClause *C)

const_child_range children() const

OpenACCSeqClause(SourceLocation BeginLoc, SourceLocation EndLoc)

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

static bool classof(const OpenACCClause *C)

llvm::ArrayRef< Expr * > getSizeExprs()

static bool classof(const OpenACCClause *C)

Expr * getDevNumExpr() const

llvm::ArrayRef< Expr * > getQueueIdExprs()

bool hasDevNumExpr() const

bool hasQueuesTag() const

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

SourceLocation getQueuesLoc() const

static bool classof(const OpenACCClause *C)

Encodes a location in the source.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Stmt - This represents one statement.

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

OpenACCClauseKind

Represents the kind of an OpenACC clause.

@ Auto

'auto' clause, allowed on 'loop' directives.

@ Gang

'gang' clause, allowed on 'loop' and Combined constructs.

@ Wait

'wait' clause, allowed on Compute, Data, 'update', and Combined constructs.

@ DevicePtr

'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.

@ PCopyOut

'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.

@ VectorLength

'vector_length' clause, allowed on 'parallel', 'kernels', 'parallel loop', and 'kernels loop' constru...

@ Async

'async' clause, allowed on Compute, Data, 'update', 'wait', and Combined constructs.

@ PresentOrCreate

'create' clause alias 'present_or_create'.

@ Collapse

'collapse' clause, allowed on 'loop' and Combined constructs.

@ PresentOrCopy

'copy' clause alias 'present_or_copy'. Preserved for diagnostic purposes.

@ DeviceNum

'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.

@ Private

'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...

@ Vector

'vector' clause, allowed on 'loop', Combined, and 'routine' directives.

@ Copy

'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.

@ Worker

'worker' clause, allowed on 'loop', Combined, and 'routine' directives.

@ Create

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

@ DeviceType

'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...

@ DefaultAsync

'default_async' clause, allowed on 'set' construct.

@ Attach

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

@ NumGangs

'num_gangs' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs.

@ If

'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...

@ Default

'default' clause, allowed on parallel, serial, kernel (and compound) constructs.

@ UseDevice

'use_device' clause, allowed on 'host_data' construct.

@ NoCreate

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

@ PresentOrCopyOut

'copyout' clause alias 'present_or_copyout'.

@ Reduction

'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

@ CopyOut

'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...

@ Seq

'seq' clause, allowed on 'loop' and 'routine' directives.

@ FirstPrivate

'firstprivate' clause, allowed on 'parallel', 'serial', 'parallel loop', and 'serial loop' constructs...

@ Host

'host' clause, allowed on 'update' construct.

@ PCopy

'copy' clause alias 'pcopy'. Preserved for diagnostic purposes.

@ Tile

'tile' clause, allowed on 'loop' and Combined constructs.

@ PCopyIn

'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.

@ PCreate

'create' clause alias 'pcreate'. Preserved for diagnostic purposes.

@ Present

'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.

@ DType

'dtype' clause, an alias for 'device_type', stored separately for diagnostic purposes.

@ CopyIn

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

@ Device

'device' clause, allowed on the 'update' construct.

@ Independent

'independent' clause, allowed on 'loop' directives.

@ NumWorkers

'num_workers' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs...

@ IfPresent

'if_present' clause, allowed on 'host_data' and 'update' directives.

@ Detach

'detach' clause, allowed on the 'exit data' construct.

@ Delete

'delete' clause, allowed on the 'exit data' construct.

@ PresentOrCopyIn

'copyin' clause alias 'present_or_copyin'.

@ Finalize

'finalize' clause, allowed on 'exit data' directive.

@ Present

'present' option.

std::pair< IdentifierInfo *, SourceLocation > DeviceTypeArgument

Describes how types, statements, expressions, and declarations should be printed.