StmtOpenMP.cpp Source File (original) (raw)

16using namespace clang;

17using namespace llvm::omp;

19size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt,

20 unsigned NumChildren) {

21 return llvm::alignTo(

22 totalSizeToAlloc<OMPClause *, Stmt *>(

23 NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)),

25}

28 assert(Clauses.size() == NumClauses &&

29 "Number of clauses is not the same as the preallocated buffer");

30 llvm::copy(Clauses, getTrailingObjects<OMPClause *>());

31}

35}

38 auto *Data = CreateEmpty(Mem, Clauses.size());

39 Data->setClauses(Clauses);

41}

44 Stmt *S, unsigned NumChildren) {

45 auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren);

46 Data->setClauses(Clauses);

47 if (S)

48 Data->setAssociatedStmt(S);

50}

52OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses,

53 bool HasAssociatedStmt,

54 unsigned NumChildren) {

55 return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);

56}

62 if (isa(this) ||

63 isa(this) ||

64 isa(this))

65 return true;

67}

71 "Standalone Executable Directives don't have Structured Blocks.");

72 if (auto *LD = dyn_cast(this))

73 return LD->getBody();

75}

79 bool TryImperfectlyNestedLoops) {

80 Stmt *OrigStmt = CurStmt;

83 if (TryImperfectlyNestedLoops) {

84 if (auto *CS = dyn_cast(CurStmt)) {

85 CurStmt = nullptr;

88 while (!Statements.empty()) {

89 CS = Statements.pop_back_val();

90 if (!CS)

91 continue;

92 for (Stmt *S : CS->body()) {

93 if (!S)

94 continue;

95 if (auto *CanonLoop = dyn_cast(S))

96 S = CanonLoop->getLoopStmt();

97 if (isa(S) || isa(S) ||

98 (isa(S) && !isa(S))) {

100 if (CurStmt) {

101 CurStmt = OrigStmt;

102 break;

103 }

104 CurStmt = S;

105 continue;

106 }

107 S = S->IgnoreContainers();

108 if (auto *InnerCS = dyn_cast_or_null(S))

109 NextStatements.push_back(InnerCS);

110 }

111 if (Statements.empty()) {

112

113 if (CurStmt)

114 break;

115 Statements.swap(NextStatements);

116 }

117 }

118 if (!CurStmt)

119 CurStmt = OrigStmt;

120 }

121 }

122 return CurStmt;

123}

124

126 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,

127 llvm::function_ref<bool(unsigned, Stmt *)> Callback,

129 OnTransformationCallback) {

131 for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) {

132 while (true) {

133 auto *Dir = dyn_cast(CurStmt);

134 if (!Dir)

135 break;

136

137 OnTransformationCallback(Dir);

138

139 Stmt *TransformedStmt = Dir->getTransformedStmt();

140 if (!TransformedStmt) {

141 unsigned NumGeneratedLoops = Dir->getNumGeneratedLoops();

142 if (NumGeneratedLoops == 0) {

143

144

145 break;

146 }

147 if (NumGeneratedLoops > 0) {

148

149

150

151 return true;

152 }

153 }

154

155 CurStmt = TransformedStmt;

156 }

157 if (auto *CanonLoop = dyn_cast(CurStmt))

158 CurStmt = CanonLoop->getLoopStmt();

159 if (Callback(Cnt, CurStmt))

160 return false;

161

162

163

164

165

166 if (auto *For = dyn_cast(CurStmt)) {

167 CurStmt = For->getBody();

168 } else {

169 assert(isa(CurStmt) &&

170 "Expected canonical for or range-based for loops.");

171 CurStmt = cast(CurStmt)->getBody();

172 }

174 CurStmt, TryImperfectlyNestedLoops);

175 }

176 return true;

177}

178

180 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,

181 llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) {

183 CurStmt, TryImperfectlyNestedLoops, NumLoops,

184 [Callback](unsigned Cnt, Stmt *Loop) {

185 Stmt *Body = nullptr;

186 if (auto *For = dyn_cast(Loop)) {

187 Body = For->getBody();

188 } else {

189 assert(isa(Loop) &&

190 "Expected canonical for or range-based for loops.");

191 Body = cast(Loop)->getBody();

192 }

193 if (auto *CanonLoop = dyn_cast(Body))

194 Body = CanonLoop->getLoopStmt();

195 Callback(Cnt, Loop, Body);

196 return false;

197 });

198 assert(Res && "Expected only loops");

199 (void)Res;

200}

201

203

204 Stmt *Body = nullptr;

206 Data->getRawStmt(), true,

208 [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; });

209 return Body;

210}

211

214 "Number of loop counters is not the same as the collapsed number");

215 llvm::copy(A, getCounters().begin());

216}

217

219 assert(A.size() == getLoopsNumber() && "Number of loop private counters "

220 "is not the same as the collapsed "

221 "number");

222 llvm::copy(A, getPrivateCounters().begin());

223}

224

227 "Number of counter inits is not the same as the collapsed number");

228 llvm::copy(A, getInits().begin());

229}

230

233 "Number of counter updates is not the same as the collapsed number");

234 llvm::copy(A, getUpdates().begin());

235}

236

239 "Number of counter finals is not the same as the collapsed number");

240 llvm::copy(A, getFinals().begin());

241}

242

244 assert(

246 "Number of dependent counters is not the same as the collapsed number");

247 llvm::copy(A, getDependentCounters().begin());

248}

249

252 "Number of dependent inits is not the same as the collapsed number");

253 llvm::copy(A, getDependentInits().begin());

254}

255

258 "Number of finals conditions is not the same as the collapsed number");

259 llvm::copy(A, getFinalsConditions().begin());

260}

261

267 auto *Dir = createDirective(

268 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

269 Dir->setIfStmt(IfStmt);

270 return Dir;

271}

272

274 unsigned NumClauses,

276 return createEmptyDirective(C, NumClauses,

277 true,

278 1);

279}

280

284 bool HasCancel) {

285 auto *Dir = createDirective(

286 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

287 Dir->setTaskReductionRefExpr(TaskRedRef);

288 Dir->setHasCancel(HasCancel);

289 return Dir;

290}

291

293 unsigned NumClauses,

295 return createEmptyDirective(C, NumClauses,

296 true,

297 1);

298}

299

305 auto *Dir = createDirective(

306 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),

307 StartLoc, EndLoc, CollapsedNum);

311 Dir->setPreCond(Exprs.PreCond);

312 Dir->setCond(Exprs.Cond);

313 Dir->setInit(Exprs.Init);

314 Dir->setInc(Exprs.Inc);

315 Dir->setCounters(Exprs.Counters);

317 Dir->setInits(Exprs.Inits);

318 Dir->setUpdates(Exprs.Updates);

319 Dir->setFinals(Exprs.Finals);

323 Dir->setPreInits(Exprs.PreInits);

324 return Dir;

325}

326

328 unsigned NumClauses,

329 unsigned CollapsedNum,

331 return createEmptyDirective(

332 C, NumClauses, true,

334}

335

339 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

340 auto *Dir = createDirective(

341 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,

342 StartLoc, EndLoc, CollapsedNum);

346 Dir->setPreCond(Exprs.PreCond);

347 Dir->setCond(Exprs.Cond);

348 Dir->setInit(Exprs.Init);

349 Dir->setInc(Exprs.Inc);

350 Dir->setIsLastIterVariable(Exprs.IL);

351 Dir->setLowerBoundVariable(Exprs.LB);

352 Dir->setUpperBoundVariable(Exprs.UB);

353 Dir->setStrideVariable(Exprs.ST);

354 Dir->setEnsureUpperBound(Exprs.EUB);

355 Dir->setNextLowerBound(Exprs.NLB);

356 Dir->setNextUpperBound(Exprs.NUB);

358 Dir->setCounters(Exprs.Counters);

360 Dir->setInits(Exprs.Inits);

361 Dir->setUpdates(Exprs.Updates);

362 Dir->setFinals(Exprs.Finals);

366 Dir->setPreInits(Exprs.PreInits);

367 Dir->setTaskReductionRefExpr(TaskRedRef);

368 Dir->setHasCancel(HasCancel);

369 return Dir;

370}

371

374#define STMT(CLASS, PARENT)

375#define ABSTRACT_STMT(CLASS)

376#define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \

377 case Stmt::CLASS##Class: \

378 return static_cast<const CLASS *>(this)->getTransformedStmt();

379#include "clang/AST/StmtNodes.inc"

380 default:

381 llvm_unreachable("Not a loop transformation");

382 }

383}

384

387#define STMT(CLASS, PARENT)

388#define ABSTRACT_STMT(CLASS)

389#define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \

390 case Stmt::CLASS##Class: \

391 return static_cast<const CLASS *>(this)->getPreInits();

392#include "clang/AST/StmtNodes.inc"

393 default:

394 llvm_unreachable("Not a loop transformation");

395 }

396}

397

399 unsigned NumClauses,

400 unsigned CollapsedNum,

402 return createEmptyDirective(

403 C, NumClauses, true,

404 numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum);

405}

406

410 unsigned NumLoops, Stmt *AssociatedStmt,

411 Stmt *TransformedStmt, Stmt *PreInits) {

413 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,

414 NumLoops);

415 Dir->setTransformedStmt(TransformedStmt);

416 Dir->setPreInits(PreInits);

417 return Dir;

418}

419

421 unsigned NumClauses,

422 unsigned NumLoops) {

423 return createEmptyDirective(

424 C, NumClauses, true, TransformedStmtOffset + 1,

426}

427

431 Stmt *AssociatedStmt, unsigned NumGeneratedLoops,

432 Stmt *TransformedStmt, Stmt *PreInits) {

433 assert(NumGeneratedLoops <= 1 && "Unrolling generates at most one loop");

434

435 auto *Dir = createDirective(

436 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);

437 Dir->setNumGeneratedLoops(NumGeneratedLoops);

438 Dir->setTransformedStmt(TransformedStmt);

439 Dir->setPreInits(PreInits);

440 return Dir;

441}

442

444 unsigned NumClauses) {

445 return createEmptyDirective(

446 C, NumClauses, true, TransformedStmtOffset + 1,

448}

449

453 Stmt *TransformedStmt, Stmt *PreInits) {

455 C, {}, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);

456 Dir->setTransformedStmt(TransformedStmt);

457 Dir->setPreInits(PreInits);

458 return Dir;

459}

460

462 return createEmptyDirective(

463 C, 0, true,

465}

466

470 Stmt *TransformedStmt, Stmt *PreInits) {

472 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,

473 NumLoops);

474 Dir->setTransformedStmt(TransformedStmt);

475 Dir->setPreInits(PreInits);

476 return Dir;

477}

478

481 unsigned NumLoops) {

482 return createEmptyDirective(

483 C, NumClauses, true, TransformedStmtOffset + 1,

485}

486

492 auto *Dir = createDirective(

493 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),

494 StartLoc, EndLoc, CollapsedNum);

498 Dir->setPreCond(Exprs.PreCond);

499 Dir->setCond(Exprs.Cond);

500 Dir->setInit(Exprs.Init);

501 Dir->setInc(Exprs.Inc);

502 Dir->setIsLastIterVariable(Exprs.IL);

503 Dir->setLowerBoundVariable(Exprs.LB);

504 Dir->setUpperBoundVariable(Exprs.UB);

505 Dir->setStrideVariable(Exprs.ST);

506 Dir->setEnsureUpperBound(Exprs.EUB);

507 Dir->setNextLowerBound(Exprs.NLB);

508 Dir->setNextUpperBound(Exprs.NUB);

510 Dir->setCounters(Exprs.Counters);

512 Dir->setInits(Exprs.Inits);

513 Dir->setUpdates(Exprs.Updates);

514 Dir->setFinals(Exprs.Finals);

518 Dir->setPreInits(Exprs.PreInits);

519 return Dir;

520}

521

523 unsigned NumClauses,

524 unsigned CollapsedNum,

526 return createEmptyDirective(

527 C, NumClauses, true,

528 numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);

529}

530

534 bool HasCancel) {

535 auto *Dir = createDirective(C, Clauses, AssociatedStmt,

536 1, StartLoc,

537 EndLoc);

538 Dir->setTaskReductionRefExpr(TaskRedRef);

539 Dir->setHasCancel(HasCancel);

540 return Dir;

541}

542

544 unsigned NumClauses,

546 return createEmptyDirective(C, NumClauses,

547 true,

548 1);

549}

550

554 Stmt *AssociatedStmt,

555 bool HasCancel) {

556 auto *Dir =

557 createDirective(C, {}, AssociatedStmt,

558 0, StartLoc, EndLoc);

560 return Dir;

561}

562

565 return createEmptyDirective(C, 0,

566 true);

567}

568

573 Stmt *AssociatedStmt) {

574 return createDirective(C, Clauses, AssociatedStmt,

575 0, StartLoc,

576 EndLoc);

577}

578

580 unsigned NumClauses,

582 return createEmptyDirective(C, NumClauses,

583 true);

584}

585

590 Stmt *AssociatedStmt) {

591 return createDirective(C, Clauses, AssociatedStmt,

592 0, StartLoc,

593 EndLoc);

594}

595

597 unsigned NumClauses,

599 return createEmptyDirective(C, NumClauses,

600 true);

601}

602

606 Stmt *AssociatedStmt) {

607 return createDirective(C, {}, AssociatedStmt,

608 0, StartLoc,

609 EndLoc);

610}

611

614 return createEmptyDirective(C, 0,

615 true);

616}

617

622 return createDirective(C, Clauses, AssociatedStmt,

623 0, Name,

624 StartLoc, EndLoc);

625}

626

628 unsigned NumClauses,

630 return createEmptyDirective(C, NumClauses,

631 true);

632}

633

637 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

638 auto *Dir = createDirective(

639 C, Clauses, AssociatedStmt,

640 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,

641 CollapsedNum);

645 Dir->setPreCond(Exprs.PreCond);

646 Dir->setCond(Exprs.Cond);

647 Dir->setInit(Exprs.Init);

648 Dir->setInc(Exprs.Inc);

649 Dir->setIsLastIterVariable(Exprs.IL);

650 Dir->setLowerBoundVariable(Exprs.LB);

651 Dir->setUpperBoundVariable(Exprs.UB);

652 Dir->setStrideVariable(Exprs.ST);

653 Dir->setEnsureUpperBound(Exprs.EUB);

654 Dir->setNextLowerBound(Exprs.NLB);

655 Dir->setNextUpperBound(Exprs.NUB);

657 Dir->setCounters(Exprs.Counters);

659 Dir->setInits(Exprs.Inits);

660 Dir->setUpdates(Exprs.Updates);

661 Dir->setFinals(Exprs.Finals);

665 Dir->setPreInits(Exprs.PreInits);

666 Dir->setTaskReductionRefExpr(TaskRedRef);

667 Dir->setHasCancel(HasCancel);

668 return Dir;

669}

670

674 return createEmptyDirective(

675 C, NumClauses, true,

676 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);

677}

678

683 auto *Dir = createDirective(

684 C, Clauses, AssociatedStmt,

685 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,

686 CollapsedNum);

690 Dir->setPreCond(Exprs.PreCond);

691 Dir->setCond(Exprs.Cond);

692 Dir->setInit(Exprs.Init);

693 Dir->setInc(Exprs.Inc);

694 Dir->setIsLastIterVariable(Exprs.IL);

695 Dir->setLowerBoundVariable(Exprs.LB);

696 Dir->setUpperBoundVariable(Exprs.UB);

697 Dir->setStrideVariable(Exprs.ST);

698 Dir->setEnsureUpperBound(Exprs.EUB);

699 Dir->setNextLowerBound(Exprs.NLB);

700 Dir->setNextUpperBound(Exprs.NUB);

702 Dir->setCounters(Exprs.Counters);

704 Dir->setInits(Exprs.Inits);

705 Dir->setUpdates(Exprs.Updates);

706 Dir->setFinals(Exprs.Finals);

710 Dir->setPreInits(Exprs.PreInits);

711 return Dir;

712}

713

716 unsigned NumClauses,

718 return createEmptyDirective(

719 C, NumClauses, true,

720 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);

721}

722

726 auto *Dir = createDirective(

727 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

728 Dir->setTaskReductionRefExpr(TaskRedRef);

729 return Dir;

730}

731

735 return createEmptyDirective(

736 C, NumClauses, true, 1);

737}

738

742 auto *Dir = createDirective(

743 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

744 Dir->setTaskReductionRefExpr(TaskRedRef);

745 return Dir;

746}

747

751 return createEmptyDirective(

752 C, NumClauses, true, 1);

753}

754

758 bool HasCancel) {

759 auto *Dir = createDirective(

760 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

761 Dir->setTaskReductionRefExpr(TaskRedRef);

762 Dir->setHasCancel(HasCancel);

763 return Dir;

764}

765

769 return createEmptyDirective(

770 C, NumClauses, true, 1);

771}

772

776 Stmt *AssociatedStmt, bool HasCancel) {

777 auto *Dir = createDirective(

778 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

779 Dir->setHasCancel(HasCancel);

780 return Dir;

781}

782

784 unsigned NumClauses,

786 return createEmptyDirective(C, NumClauses,

787 true);

788}

789

794}

795

799}

800

805 Stmt *AStmt) {

806 return createDirective(C, Clauses, AStmt,

807 0, StartLoc,

808 EndLoc);

809}

810

812 unsigned NumClauses,

814 return createEmptyDirective(C, NumClauses,

815 true);

816}

817

822 return createDirective(

823 C, Clauses, nullptr, 0, StartLoc,

824 EndLoc);

825}

826

828 unsigned NumClauses,

830 return createEmptyDirective(C, NumClauses);

831}

832

837}

838

842}

843

848 return createDirective(

849 C, Clauses, nullptr, 0, StartLoc,

850 EndLoc);

851}

852

854 unsigned NumClauses,

856 return createEmptyDirective(C, NumClauses);

857}

858

862 auto *Dir = createDirective(

863 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

864 Dir->setReductionRef(ReductionRef);

865 return Dir;

866}

867

869 unsigned NumClauses,

871 return createEmptyDirective(

872 C, NumClauses, true, 1);

873}

874

879 Dir->setCancelRegion(CancelRegion);

880 return Dir;

881}

882

886}

887

892 auto *Dir = createDirective(

893 C, Clauses, nullptr, 0, StartLoc,

894 EndLoc);

895 Dir->setCancelRegion(CancelRegion);

896 return Dir;

897}

898

900 unsigned NumClauses,

902 return createEmptyDirective(C, NumClauses);

903}

904

909 return createDirective(

910 C, Clauses, nullptr, 0, StartLoc,

911 EndLoc);

912}

913

915 unsigned NumClauses,

917 return createEmptyDirective(C, NumClauses);

918}

919

924 return createDirective(

925 C, Clauses, nullptr,

926 0, StartLoc, EndLoc);

927}

928

930 unsigned NumClauses,

932 return createEmptyDirective(C, NumClauses);

933}

934

939 return createDirective(C, Clauses,

940 nullptr,

941 0, StartLoc, EndLoc);

942}

943

945 unsigned NumClauses,

947 return createEmptyDirective(C, NumClauses);

948}

949

954 Stmt *AssociatedStmt) {

955 return createDirective(

956 C, Clauses, cast_or_null(AssociatedStmt),

957 0, StartLoc, EndLoc);

958}

959

961 unsigned NumClauses,

962 bool IsStandalone,

964 return createEmptyDirective(C, NumClauses,

965 !IsStandalone);

966}

967

972 auto *Dir = createDirective(

973 C, Clauses, AssociatedStmt, 7, StartLoc, EndLoc);

974 Dir->setX(Exprs.X);

975 Dir->setV(Exprs.V);

976 Dir->setR(Exprs.R);

977 Dir->setExpr(Exprs.E);

978 Dir->setUpdateExpr(Exprs.UE);

979 Dir->setD(Exprs.D);

980 Dir->setCond(Exprs.Cond);

981 Dir->Flags.IsXLHSInRHSPart = Exprs.IsXLHSInRHSPart ? 1 : 0;

982 Dir->Flags.IsPostfixUpdate = Exprs.IsPostfixUpdate ? 1 : 0;

983 Dir->Flags.IsFailOnly = Exprs.IsFailOnly ? 1 : 0;

984 return Dir;

985}

986

988 unsigned NumClauses,

990 return createEmptyDirective(

991 C, NumClauses, true, 7);

992}

993

998 Stmt *AssociatedStmt) {

999 return createDirective(

1000 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

1001}

1002

1004 unsigned NumClauses,

1006 return createEmptyDirective(C, NumClauses,

1007 true);

1008}

1009

1013 bool HasCancel) {

1014 auto *Dir = createDirective(

1015 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);

1016 Dir->setTaskReductionRefExpr(TaskRedRef);

1017 Dir->setHasCancel(HasCancel);

1018 return Dir;

1019}

1020

1024 return createEmptyDirective(

1025 C, NumClauses, true, 1);

1026}

1027

1031 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

1032 auto *Dir = createDirective(

1033 C, Clauses, AssociatedStmt,

1034 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,

1035 EndLoc, CollapsedNum);

1039 Dir->setPreCond(Exprs.PreCond);

1040 Dir->setCond(Exprs.Cond);

1041 Dir->setInit(Exprs.Init);

1042 Dir->setInc(Exprs.Inc);

1043 Dir->setIsLastIterVariable(Exprs.IL);

1044 Dir->setLowerBoundVariable(Exprs.LB);

1045 Dir->setUpperBoundVariable(Exprs.UB);

1046 Dir->setStrideVariable(Exprs.ST);

1047 Dir->setEnsureUpperBound(Exprs.EUB);

1048 Dir->setNextLowerBound(Exprs.NLB);

1049 Dir->setNextUpperBound(Exprs.NUB);

1051 Dir->setCounters(Exprs.Counters);

1053 Dir->setInits(Exprs.Inits);

1054 Dir->setUpdates(Exprs.Updates);

1055 Dir->setFinals(Exprs.Finals);

1059 Dir->setPreInits(Exprs.PreInits);

1060 Dir->setTaskReductionRefExpr(TaskRedRef);

1061 Dir->setHasCancel(HasCancel);

1062 return Dir;

1063}

1064

1067 unsigned NumClauses,

1068 unsigned CollapsedNum, EmptyShell) {

1069 return createEmptyDirective(

1070 C, NumClauses, true,

1071 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,

1072 CollapsedNum);

1073}

1074

1078 return createDirective(

1079 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

1080}

1081

1083 unsigned N,

1085 return createEmptyDirective(

1086 C, N, true);

1087}

1088

1092 return createDirective(

1093 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

1094}

1095

1099 return createEmptyDirective(

1100 C, N, true);

1101}

1102

1106 return createDirective(

1107 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

1108}

1109

1113 return createEmptyDirective(

1114 C, N, true);

1115}

1116

1121 Stmt *AssociatedStmt) {

1122 return createDirective(

1123 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

1124}

1125

1127 unsigned NumClauses,

1129 return createEmptyDirective(C, NumClauses,

1130 true);

1131}

1132

1136 const HelperExprs &Exprs, bool HasCancel) {

1137 auto *Dir = createDirective(

1138 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),

1139 StartLoc, EndLoc, CollapsedNum);

1143 Dir->setPreCond(Exprs.PreCond);

1144 Dir->setCond(Exprs.Cond);

1145 Dir->setInit(Exprs.Init);

1146 Dir->setInc(Exprs.Inc);

1147 Dir->setIsLastIterVariable(Exprs.IL);

1148 Dir->setLowerBoundVariable(Exprs.LB);

1149 Dir->setUpperBoundVariable(Exprs.UB);

1150 Dir->setStrideVariable(Exprs.ST);

1151 Dir->setEnsureUpperBound(Exprs.EUB);

1152 Dir->setNextLowerBound(Exprs.NLB);

1153 Dir->setNextUpperBound(Exprs.NUB);

1155 Dir->setCounters(Exprs.Counters);

1157 Dir->setInits(Exprs.Inits);

1158 Dir->setUpdates(Exprs.Updates);

1159 Dir->setFinals(Exprs.Finals);

1163 Dir->setPreInits(Exprs.PreInits);

1164 Dir->setHasCancel(HasCancel);

1165 return Dir;

1166}

1167

1169 unsigned NumClauses,

1170 unsigned CollapsedNum,

1172 return createEmptyDirective(

1173 C, NumClauses, true,

1174 numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);

1175}

1176

1181 auto *Dir = createDirective(

1182 C, Clauses, AssociatedStmt,

1183 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,

1184 CollapsedNum);

1188 Dir->setPreCond(Exprs.PreCond);

1189 Dir->setCond(Exprs.Cond);

1190 Dir->setInit(Exprs.Init);

1191 Dir->setInc(Exprs.Inc);

1192 Dir->setIsLastIterVariable(Exprs.IL);

1193 Dir->setLowerBoundVariable(Exprs.LB);

1194 Dir->setUpperBoundVariable(Exprs.UB);

1195 Dir->setStrideVariable(Exprs.ST);

1196 Dir->setEnsureUpperBound(Exprs.EUB);

1197 Dir->setNextLowerBound(Exprs.NLB);

1198 Dir->setNextUpperBound(Exprs.NUB);

1200 Dir->setCounters(Exprs.Counters);

1202 Dir->setInits(Exprs.Inits);

1203 Dir->setUpdates(Exprs.Updates);

1204 Dir->setFinals(Exprs.Finals);

1208 Dir->setPreInits(Exprs.PreInits);

1209 return Dir;

1210}

1211

1214 unsigned CollapsedNum, EmptyShell) {

1215 return createEmptyDirective(

1216 C, NumClauses, true,

1217 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);

1218}

1219

1223 const HelperExprs &Exprs, bool HasCancel) {

1224 auto *Dir = createDirective(

1225 C, Clauses, AssociatedStmt,

1226 numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,

1227 CollapsedNum);

1231 Dir->setPreCond(Exprs.PreCond);

1232 Dir->setCond(Exprs.Cond);

1233 Dir->setInit(Exprs.Init);

1234 Dir->setInc(Exprs.Inc);

1235 Dir->setIsLastIterVariable(Exprs.IL);

1236 Dir->setLowerBoundVariable(Exprs.LB);

1237 Dir->setUpperBoundVariable(Exprs.UB);

1238 Dir->setStrideVariable(Exprs.ST);

1239 Dir->setEnsureUpperBound(Exprs.EUB);

1240 Dir->setNextLowerBound(Exprs.NLB);

1241 Dir->setNextUpperBound(Exprs.NUB);

1243 Dir->setCounters(Exprs.Counters);

1245 Dir->setInits(Exprs.Inits);

1246 Dir->setUpdates(Exprs.Updates);

1247 Dir->setFinals(Exprs.Finals);

1251 Dir->setPreInits(Exprs.PreInits);

1252 Dir->setHasCancel(HasCancel);

1253 return Dir;

1254}

1255

1258 unsigned NumClauses,

1259 unsigned CollapsedNum, EmptyShell) {

1260 return createEmptyDirective(

1261 C, NumClauses, true,

1262 numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);

1263}

1264

1268 const HelperExprs &Exprs, bool HasCancel) {

1269 auto *Dir = createDirective(

1270 C, Clauses, AssociatedStmt,

1271 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), StartLoc, EndLoc,

1272 CollapsedNum);

1276 Dir->setPreCond(Exprs.PreCond);

1277 Dir->setCond(Exprs.Cond);

1278 Dir->setInit(Exprs.Init);

1279 Dir->setInc(Exprs.Inc);

1280 Dir->setIsLastIterVariable(Exprs.IL);

1281 Dir->setLowerBoundVariable(Exprs.LB);

1282 Dir->setUpperBoundVariable(Exprs.UB);

1283 Dir->setStrideVariable(Exprs.ST);

1284 Dir->setEnsureUpperBound(Exprs.EUB);

1285 Dir->setNextLowerBound(Exprs.NLB);

1286 Dir->setNextUpperBound(Exprs.NUB);

1288 Dir->setCounters(Exprs.Counters);

1290 Dir->setInits(Exprs.Inits);

1291 Dir->setUpdates(Exprs.Updates);

1292 Dir->setFinals(Exprs.Finals);

1296 Dir->setPreInits(Exprs.PreInits);

1297 Dir->setHasCancel(HasCancel);

1298 return Dir;

1299}

1300

1303 unsigned NumClauses,

1304 unsigned CollapsedNum, EmptyShell) {

1305 return createEmptyDirective(

1306 C, NumClauses, true,

1307 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), CollapsedNum);

1308}

1309

1314 auto *Dir = createDirective(

1315 C, Clauses, AssociatedStmt,

1316 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,

1317 EndLoc, CollapsedNum);

1321 Dir->setPreCond(Exprs.PreCond);

1322 Dir->setCond(Exprs.Cond);

1323 Dir->setInit(Exprs.Init);

1324 Dir->setInc(Exprs.Inc);

1325 Dir->setIsLastIterVariable(Exprs.IL);

1326 Dir->setLowerBoundVariable(Exprs.LB);

1327 Dir->setUpperBoundVariable(Exprs.UB);

1328 Dir->setStrideVariable(Exprs.ST);

1329 Dir->setEnsureUpperBound(Exprs.EUB);

1330 Dir->setNextLowerBound(Exprs.NLB);

1331 Dir->setNextUpperBound(Exprs.NUB);

1333 Dir->setCounters(Exprs.Counters);

1335 Dir->setInits(Exprs.Inits);

1336 Dir->setUpdates(Exprs.Updates);

1337 Dir->setFinals(Exprs.Finals);

1341 Dir->setPreInits(Exprs.PreInits);

1342 return Dir;

1343}

1344

1347 unsigned NumClauses,

1348 unsigned CollapsedNum, EmptyShell) {

1349 return createEmptyDirective(

1350 C, NumClauses, true,

1351 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);

1352}

1353

1358 auto *Dir = createDirective(

1359 C, Clauses, AssociatedStmt,

1360 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), StartLoc,

1361 EndLoc, CollapsedNum);

1365 Dir->setPreCond(Exprs.PreCond);

1366 Dir->setCond(Exprs.Cond);

1367 Dir->setInit(Exprs.Init);

1368 Dir->setInc(Exprs.Inc);

1369 Dir->setIsLastIterVariable(Exprs.IL);

1370 Dir->setLowerBoundVariable(Exprs.LB);

1371 Dir->setUpperBoundVariable(Exprs.UB);

1372 Dir->setStrideVariable(Exprs.ST);

1373 Dir->setEnsureUpperBound(Exprs.EUB);

1374 Dir->setNextLowerBound(Exprs.NLB);

1375 Dir->setNextUpperBound(Exprs.NUB);

1377 Dir->setCounters(Exprs.Counters);

1379 Dir->setInits(Exprs.Inits);

1380 Dir->setUpdates(Exprs.Updates);

1381 Dir->setFinals(Exprs.Finals);

1385 Dir->setPreInits(Exprs.PreInits);

1386 return Dir;

1387}

1388

1391 unsigned NumClauses,

1392 unsigned CollapsedNum, EmptyShell) {

1393 return createEmptyDirective(

1394 C, NumClauses, true,

1395 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), CollapsedNum);

1396}

1397

1401 const HelperExprs &Exprs, bool HasCancel) {

1402 auto *Dir = createDirective(

1403 C, Clauses, AssociatedStmt,

1404 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,

1405 EndLoc, CollapsedNum);

1409 Dir->setPreCond(Exprs.PreCond);

1410 Dir->setCond(Exprs.Cond);

1411 Dir->setInit(Exprs.Init);

1412 Dir->setInc(Exprs.Inc);

1413 Dir->setIsLastIterVariable(Exprs.IL);

1414 Dir->setLowerBoundVariable(Exprs.LB);

1415 Dir->setUpperBoundVariable(Exprs.UB);

1416 Dir->setStrideVariable(Exprs.ST);

1417 Dir->setEnsureUpperBound(Exprs.EUB);

1418 Dir->setNextLowerBound(Exprs.NLB);

1419 Dir->setNextUpperBound(Exprs.NUB);

1421 Dir->setCounters(Exprs.Counters);

1423 Dir->setInits(Exprs.Inits);

1424 Dir->setUpdates(Exprs.Updates);

1425 Dir->setFinals(Exprs.Finals);

1429 Dir->setPreInits(Exprs.PreInits);

1430 Dir->setHasCancel(HasCancel);

1431 return Dir;

1432}

1433

1436 unsigned NumClauses,

1437 unsigned CollapsedNum,

1439 return createEmptyDirective(

1440 C, NumClauses, true,

1441 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),

1442 CollapsedNum);

1443}

1444

1448 const HelperExprs &Exprs, bool HasCancel) {

1449 auto *Dir = createDirective(

1450 C, Clauses, AssociatedStmt,

1451 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop), StartLoc,

1452 EndLoc, CollapsedNum);

1456 Dir->setPreCond(Exprs.PreCond);

1457 Dir->setCond(Exprs.Cond);

1458 Dir->setInit(Exprs.Init);

1459 Dir->setInc(Exprs.Inc);

1460 Dir->setIsLastIterVariable(Exprs.IL);

1461 Dir->setLowerBoundVariable(Exprs.LB);

1462 Dir->setUpperBoundVariable(Exprs.UB);

1463 Dir->setStrideVariable(Exprs.ST);

1464 Dir->setEnsureUpperBound(Exprs.EUB);

1465 Dir->setNextLowerBound(Exprs.NLB);

1466 Dir->setNextUpperBound(Exprs.NUB);

1468 Dir->setCounters(Exprs.Counters);

1470 Dir->setInits(Exprs.Inits);

1471 Dir->setUpdates(Exprs.Updates);

1472 Dir->setFinals(Exprs.Finals);

1476 Dir->setPreInits(Exprs.PreInits);

1477 Dir->setHasCancel(HasCancel);

1478 return Dir;

1479}

1480

1483 unsigned NumClauses,

1484 unsigned CollapsedNum,

1486 return createEmptyDirective(

1487 C, NumClauses, true,

1488 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop),

1489 CollapsedNum);

1490}

1491

1497 auto *Dir = createDirective(

1498 C, Clauses, AssociatedStmt,

1499 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),

1500 StartLoc, EndLoc, CollapsedNum);

1504 Dir->setPreCond(Exprs.PreCond);

1505 Dir->setCond(Exprs.Cond);

1506 Dir->setInit(Exprs.Init);

1507 Dir->setInc(Exprs.Inc);

1508 Dir->setIsLastIterVariable(Exprs.IL);

1509 Dir->setLowerBoundVariable(Exprs.LB);

1510 Dir->setUpperBoundVariable(Exprs.UB);

1511 Dir->setStrideVariable(Exprs.ST);

1512 Dir->setEnsureUpperBound(Exprs.EUB);

1513 Dir->setNextLowerBound(Exprs.NLB);

1514 Dir->setNextUpperBound(Exprs.NUB);

1516 Dir->setCounters(Exprs.Counters);

1518 Dir->setInits(Exprs.Inits);

1519 Dir->setUpdates(Exprs.Updates);

1520 Dir->setFinals(Exprs.Finals);

1524 Dir->setPreInits(Exprs.PreInits);

1525 return Dir;

1526}

1527

1530 unsigned NumClauses,

1531 unsigned CollapsedNum,

1533 return createEmptyDirective(

1534 C, NumClauses, true,

1535 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),

1536 CollapsedNum);

1537}

1538

1544 auto *Dir = createDirective(

1545 C, Clauses, AssociatedStmt,

1546 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),

1547 StartLoc, EndLoc, CollapsedNum);

1551 Dir->setPreCond(Exprs.PreCond);

1552 Dir->setCond(Exprs.Cond);

1553 Dir->setInit(Exprs.Init);

1554 Dir->setInc(Exprs.Inc);

1555 Dir->setIsLastIterVariable(Exprs.IL);

1556 Dir->setLowerBoundVariable(Exprs.LB);

1557 Dir->setUpperBoundVariable(Exprs.UB);

1558 Dir->setStrideVariable(Exprs.ST);

1559 Dir->setEnsureUpperBound(Exprs.EUB);

1560 Dir->setNextLowerBound(Exprs.NLB);

1561 Dir->setNextUpperBound(Exprs.NUB);

1563 Dir->setCounters(Exprs.Counters);

1565 Dir->setInits(Exprs.Inits);

1566 Dir->setUpdates(Exprs.Updates);

1567 Dir->setFinals(Exprs.Finals);

1571 Dir->setPreInits(Exprs.PreInits);

1572 return Dir;

1573}

1574

1577 unsigned NumClauses,

1578 unsigned CollapsedNum,

1580 return createEmptyDirective(

1581 C, NumClauses, true,

1582 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),

1583 CollapsedNum);

1584}

1585

1591 auto *Dir = createDirective(

1592 C, Clauses, AssociatedStmt,

1593 numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,

1594 CollapsedNum);

1598 Dir->setPreCond(Exprs.PreCond);

1599 Dir->setCond(Exprs.Cond);

1600 Dir->setInit(Exprs.Init);

1601 Dir->setInc(Exprs.Inc);

1602 Dir->setIsLastIterVariable(Exprs.IL);

1603 Dir->setLowerBoundVariable(Exprs.LB);

1604 Dir->setUpperBoundVariable(Exprs.UB);

1605 Dir->setStrideVariable(Exprs.ST);

1606 Dir->setEnsureUpperBound(Exprs.EUB);

1607 Dir->setNextLowerBound(Exprs.NLB);

1608 Dir->setNextUpperBound(Exprs.NUB);

1610 Dir->setCounters(Exprs.Counters);

1612 Dir->setInits(Exprs.Inits);

1613 Dir->setUpdates(Exprs.Updates);

1614 Dir->setFinals(Exprs.Finals);

1618 Dir->setPreInits(Exprs.PreInits);

1619 return Dir;

1620}

1621

1624 unsigned CollapsedNum, EmptyShell) {

1625 return createEmptyDirective(

1626 C, NumClauses, true,

1627 numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);

1628}

1629

1633 return createDirective(C, Clauses, AssociatedStmt,

1634 0, StartLoc,

1635 EndLoc);

1636}

1637

1641 return createEmptyDirective(

1642 C, NumClauses, true);

1643}

1644

1648 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

1649 auto *Dir = createDirective(

1650 C, Clauses, AssociatedStmt,

1651 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,

1652 EndLoc, CollapsedNum);

1656 Dir->setPreCond(Exprs.PreCond);

1657 Dir->setCond(Exprs.Cond);

1658 Dir->setInit(Exprs.Init);

1659 Dir->setInc(Exprs.Inc);

1660 Dir->setIsLastIterVariable(Exprs.IL);

1661 Dir->setLowerBoundVariable(Exprs.LB);

1662 Dir->setUpperBoundVariable(Exprs.UB);

1663 Dir->setStrideVariable(Exprs.ST);

1664 Dir->setEnsureUpperBound(Exprs.EUB);

1665 Dir->setNextLowerBound(Exprs.NLB);

1666 Dir->setNextUpperBound(Exprs.NUB);

1668 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

1669 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

1670 Dir->setDistInc(Exprs.DistInc);

1671 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

1672 Dir->setCounters(Exprs.Counters);

1674 Dir->setInits(Exprs.Inits);

1675 Dir->setUpdates(Exprs.Updates);

1676 Dir->setFinals(Exprs.Finals);

1680 Dir->setPreInits(Exprs.PreInits);

1690 Dir->setTaskReductionRefExpr(TaskRedRef);

1691 Dir->HasCancel = HasCancel;

1692 return Dir;

1693}

1694

1697 unsigned NumClauses,

1698 unsigned CollapsedNum,

1700 return createEmptyDirective(

1701 C, NumClauses, true,

1702 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,

1703 CollapsedNum);

1704}

1705

1711 auto *Dir = createDirective(

1712 C, Clauses, AssociatedStmt,

1713 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),

1714 StartLoc, EndLoc, CollapsedNum);

1718 Dir->setPreCond(Exprs.PreCond);

1719 Dir->setCond(Exprs.Cond);

1720 Dir->setInit(Exprs.Init);

1721 Dir->setInc(Exprs.Inc);

1722 Dir->setIsLastIterVariable(Exprs.IL);

1723 Dir->setLowerBoundVariable(Exprs.LB);

1724 Dir->setUpperBoundVariable(Exprs.UB);

1725 Dir->setStrideVariable(Exprs.ST);

1726 Dir->setEnsureUpperBound(Exprs.EUB);

1727 Dir->setNextLowerBound(Exprs.NLB);

1728 Dir->setNextUpperBound(Exprs.NUB);

1730 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

1731 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

1732 Dir->setDistInc(Exprs.DistInc);

1733 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

1734 Dir->setCounters(Exprs.Counters);

1736 Dir->setInits(Exprs.Inits);

1737 Dir->setUpdates(Exprs.Updates);

1738 Dir->setFinals(Exprs.Finals);

1742 Dir->setPreInits(Exprs.PreInits);

1752 return Dir;

1753}

1754

1757 unsigned NumClauses,

1758 unsigned CollapsedNum,

1760 return createEmptyDirective(

1761 C, NumClauses, true,

1762 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),

1763 CollapsedNum);

1764}

1765

1770 auto *Dir = createDirective(

1771 C, Clauses, AssociatedStmt,

1772 numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,

1773 CollapsedNum);

1777 Dir->setPreCond(Exprs.PreCond);

1778 Dir->setCond(Exprs.Cond);

1779 Dir->setInit(Exprs.Init);

1780 Dir->setInc(Exprs.Inc);

1781 Dir->setIsLastIterVariable(Exprs.IL);

1782 Dir->setLowerBoundVariable(Exprs.LB);

1783 Dir->setUpperBoundVariable(Exprs.UB);

1784 Dir->setStrideVariable(Exprs.ST);

1785 Dir->setEnsureUpperBound(Exprs.EUB);

1786 Dir->setNextLowerBound(Exprs.NLB);

1787 Dir->setNextUpperBound(Exprs.NUB);

1789 Dir->setCounters(Exprs.Counters);

1791 Dir->setInits(Exprs.Inits);

1792 Dir->setUpdates(Exprs.Updates);

1793 Dir->setFinals(Exprs.Finals);

1797 Dir->setPreInits(Exprs.PreInits);

1798 return Dir;

1799}

1800

1803 unsigned NumClauses,

1804 unsigned CollapsedNum, EmptyShell) {

1805 return createEmptyDirective(

1806 C, NumClauses, true,

1807 numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);

1808}

1809

1814 auto *Dir = createDirective(

1815 C, Clauses, AssociatedStmt,

1816 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,

1817 EndLoc, CollapsedNum);

1821 Dir->setPreCond(Exprs.PreCond);

1822 Dir->setCond(Exprs.Cond);

1823 Dir->setInit(Exprs.Init);

1824 Dir->setInc(Exprs.Inc);

1825 Dir->setIsLastIterVariable(Exprs.IL);

1826 Dir->setLowerBoundVariable(Exprs.LB);

1827 Dir->setUpperBoundVariable(Exprs.UB);

1828 Dir->setStrideVariable(Exprs.ST);

1829 Dir->setEnsureUpperBound(Exprs.EUB);

1830 Dir->setNextLowerBound(Exprs.NLB);

1831 Dir->setNextUpperBound(Exprs.NUB);

1833 Dir->setCounters(Exprs.Counters);

1835 Dir->setInits(Exprs.Inits);

1836 Dir->setUpdates(Exprs.Updates);

1837 Dir->setFinals(Exprs.Finals);

1841 Dir->setPreInits(Exprs.PreInits);

1842 return Dir;

1843}

1844

1847 unsigned NumClauses,

1848 unsigned CollapsedNum,

1850 return createEmptyDirective(

1851 C, NumClauses, true,

1852 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),

1853 CollapsedNum);

1854}

1855

1861 auto *Dir = createDirective(

1862 C, Clauses, AssociatedStmt,

1863 numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,

1864 CollapsedNum);

1868 Dir->setPreCond(Exprs.PreCond);

1869 Dir->setCond(Exprs.Cond);

1870 Dir->setInit(Exprs.Init);

1871 Dir->setInc(Exprs.Inc);

1872 Dir->setCounters(Exprs.Counters);

1874 Dir->setInits(Exprs.Inits);

1875 Dir->setUpdates(Exprs.Updates);

1876 Dir->setFinals(Exprs.Finals);

1880 Dir->setPreInits(Exprs.PreInits);

1881 return Dir;

1882}

1883

1886 unsigned CollapsedNum, EmptyShell) {

1887 return createEmptyDirective(

1888 C, NumClauses, true,

1889 numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);

1890}

1891

1896 auto *Dir = createDirective(

1897 C, Clauses, AssociatedStmt,

1898 numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,

1899 CollapsedNum);

1903 Dir->setPreCond(Exprs.PreCond);

1904 Dir->setCond(Exprs.Cond);

1905 Dir->setInit(Exprs.Init);

1906 Dir->setInc(Exprs.Inc);

1907 Dir->setIsLastIterVariable(Exprs.IL);

1908 Dir->setLowerBoundVariable(Exprs.LB);

1909 Dir->setUpperBoundVariable(Exprs.UB);

1910 Dir->setStrideVariable(Exprs.ST);

1911 Dir->setEnsureUpperBound(Exprs.EUB);

1912 Dir->setNextLowerBound(Exprs.NLB);

1913 Dir->setNextUpperBound(Exprs.NUB);

1915 Dir->setCounters(Exprs.Counters);

1917 Dir->setInits(Exprs.Inits);

1918 Dir->setUpdates(Exprs.Updates);

1919 Dir->setFinals(Exprs.Finals);

1923 Dir->setPreInits(Exprs.PreInits);

1924 return Dir;

1925}

1926

1929 unsigned NumClauses,

1930 unsigned CollapsedNum, EmptyShell) {

1931 return createEmptyDirective(

1932 C, NumClauses, true,

1933 numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);

1934}

1935

1940 auto *Dir = createDirective(

1941 C, Clauses, AssociatedStmt,

1942 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,

1943 EndLoc, CollapsedNum);

1947 Dir->setPreCond(Exprs.PreCond);

1948 Dir->setCond(Exprs.Cond);

1949 Dir->setInit(Exprs.Init);

1950 Dir->setInc(Exprs.Inc);

1951 Dir->setIsLastIterVariable(Exprs.IL);

1952 Dir->setLowerBoundVariable(Exprs.LB);

1953 Dir->setUpperBoundVariable(Exprs.UB);

1954 Dir->setStrideVariable(Exprs.ST);

1955 Dir->setEnsureUpperBound(Exprs.EUB);

1956 Dir->setNextLowerBound(Exprs.NLB);

1957 Dir->setNextUpperBound(Exprs.NUB);

1959 Dir->setCounters(Exprs.Counters);

1961 Dir->setInits(Exprs.Inits);

1962 Dir->setUpdates(Exprs.Updates);

1963 Dir->setFinals(Exprs.Finals);

1967 Dir->setPreInits(Exprs.PreInits);

1968 return Dir;

1969}

1970

1972 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,

1974 return createEmptyDirective(

1975 C, NumClauses, true,

1976 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);

1977}

1978

1984 auto *Dir = createDirective(

1985 C, Clauses, AssociatedStmt,

1986 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),

1987 StartLoc, EndLoc, CollapsedNum);

1991 Dir->setPreCond(Exprs.PreCond);

1992 Dir->setCond(Exprs.Cond);

1993 Dir->setInit(Exprs.Init);

1994 Dir->setInc(Exprs.Inc);

1995 Dir->setIsLastIterVariable(Exprs.IL);

1996 Dir->setLowerBoundVariable(Exprs.LB);

1997 Dir->setUpperBoundVariable(Exprs.UB);

1998 Dir->setStrideVariable(Exprs.ST);

1999 Dir->setEnsureUpperBound(Exprs.EUB);

2000 Dir->setNextLowerBound(Exprs.NLB);

2001 Dir->setNextUpperBound(Exprs.NUB);

2003 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2004 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2005 Dir->setDistInc(Exprs.DistInc);

2006 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2007 Dir->setCounters(Exprs.Counters);

2009 Dir->setInits(Exprs.Inits);

2010 Dir->setUpdates(Exprs.Updates);

2011 Dir->setFinals(Exprs.Finals);

2015 Dir->setPreInits(Exprs.PreInits);

2025 return Dir;

2026}

2027

2030 unsigned NumClauses,

2031 unsigned CollapsedNum,

2033 return createEmptyDirective(

2034 C, NumClauses, true,

2035 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),

2036 CollapsedNum);

2037}

2038

2043 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

2044 auto *Dir = createDirective(

2045 C, Clauses, AssociatedStmt,

2046 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,

2047 StartLoc, EndLoc, CollapsedNum);

2051 Dir->setPreCond(Exprs.PreCond);

2052 Dir->setCond(Exprs.Cond);

2053 Dir->setInit(Exprs.Init);

2054 Dir->setInc(Exprs.Inc);

2055 Dir->setIsLastIterVariable(Exprs.IL);

2056 Dir->setLowerBoundVariable(Exprs.LB);

2057 Dir->setUpperBoundVariable(Exprs.UB);

2058 Dir->setStrideVariable(Exprs.ST);

2059 Dir->setEnsureUpperBound(Exprs.EUB);

2060 Dir->setNextLowerBound(Exprs.NLB);

2061 Dir->setNextUpperBound(Exprs.NUB);

2063 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2064 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2065 Dir->setDistInc(Exprs.DistInc);

2066 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2067 Dir->setCounters(Exprs.Counters);

2069 Dir->setInits(Exprs.Inits);

2070 Dir->setUpdates(Exprs.Updates);

2071 Dir->setFinals(Exprs.Finals);

2075 Dir->setPreInits(Exprs.PreInits);

2085 Dir->setTaskReductionRefExpr(TaskRedRef);

2086 Dir->HasCancel = HasCancel;

2087 return Dir;

2088}

2089

2092 unsigned NumClauses,

2093 unsigned CollapsedNum,

2095 return createEmptyDirective(

2096 C, NumClauses, true,

2097 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,

2098 CollapsedNum);

2099}

2100

2104 return createDirective(C, Clauses, AssociatedStmt,

2105 0, StartLoc,

2106 EndLoc);

2107}

2108

2112 return createEmptyDirective(

2113 C, NumClauses, true);

2114}

2115

2120 auto *Dir = createDirective(

2121 C, Clauses, AssociatedStmt,

2122 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,

2123 EndLoc, CollapsedNum);

2127 Dir->setPreCond(Exprs.PreCond);

2128 Dir->setCond(Exprs.Cond);

2129 Dir->setInit(Exprs.Init);

2130 Dir->setInc(Exprs.Inc);

2131 Dir->setIsLastIterVariable(Exprs.IL);

2132 Dir->setLowerBoundVariable(Exprs.LB);

2133 Dir->setUpperBoundVariable(Exprs.UB);

2134 Dir->setStrideVariable(Exprs.ST);

2135 Dir->setEnsureUpperBound(Exprs.EUB);

2136 Dir->setNextLowerBound(Exprs.NLB);

2137 Dir->setNextUpperBound(Exprs.NUB);

2139 Dir->setCounters(Exprs.Counters);

2141 Dir->setInits(Exprs.Inits);

2142 Dir->setUpdates(Exprs.Updates);

2143 Dir->setFinals(Exprs.Finals);

2147 Dir->setPreInits(Exprs.PreInits);

2148 return Dir;

2149}

2150

2153 unsigned NumClauses,

2154 unsigned CollapsedNum,

2156 return createEmptyDirective(

2157 C, NumClauses, true,

2158 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),

2159 CollapsedNum);

2160}

2161

2166 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

2167 auto *Dir = createDirective(

2168 C, Clauses, AssociatedStmt,

2169 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +

2170 1,

2171 StartLoc, EndLoc, CollapsedNum);

2175 Dir->setPreCond(Exprs.PreCond);

2176 Dir->setCond(Exprs.Cond);

2177 Dir->setInit(Exprs.Init);

2178 Dir->setInc(Exprs.Inc);

2179 Dir->setIsLastIterVariable(Exprs.IL);

2180 Dir->setLowerBoundVariable(Exprs.LB);

2181 Dir->setUpperBoundVariable(Exprs.UB);

2182 Dir->setStrideVariable(Exprs.ST);

2183 Dir->setEnsureUpperBound(Exprs.EUB);

2184 Dir->setNextLowerBound(Exprs.NLB);

2185 Dir->setNextUpperBound(Exprs.NUB);

2187 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2188 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2189 Dir->setDistInc(Exprs.DistInc);

2190 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2191 Dir->setCounters(Exprs.Counters);

2193 Dir->setInits(Exprs.Inits);

2194 Dir->setUpdates(Exprs.Updates);

2195 Dir->setFinals(Exprs.Finals);

2199 Dir->setPreInits(Exprs.PreInits);

2209 Dir->setTaskReductionRefExpr(TaskRedRef);

2210 Dir->HasCancel = HasCancel;

2211 return Dir;

2212}

2213

2216 unsigned NumClauses,

2217 unsigned CollapsedNum,

2219 return createEmptyDirective(

2220 C, NumClauses, true,

2221 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +

2222 1,

2223 CollapsedNum);

2224}

2225

2231 auto *Dir = createDirective(

2232 C, Clauses, AssociatedStmt,

2234 OMPD_target_teams_distribute_parallel_for_simd),

2235 StartLoc, EndLoc, CollapsedNum);

2239 Dir->setPreCond(Exprs.PreCond);

2240 Dir->setCond(Exprs.Cond);

2241 Dir->setInit(Exprs.Init);

2242 Dir->setInc(Exprs.Inc);

2243 Dir->setIsLastIterVariable(Exprs.IL);

2244 Dir->setLowerBoundVariable(Exprs.LB);

2245 Dir->setUpperBoundVariable(Exprs.UB);

2246 Dir->setStrideVariable(Exprs.ST);

2247 Dir->setEnsureUpperBound(Exprs.EUB);

2248 Dir->setNextLowerBound(Exprs.NLB);

2249 Dir->setNextUpperBound(Exprs.NUB);

2251 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2252 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2253 Dir->setDistInc(Exprs.DistInc);

2254 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2255 Dir->setCounters(Exprs.Counters);

2257 Dir->setInits(Exprs.Inits);

2258 Dir->setUpdates(Exprs.Updates);

2259 Dir->setFinals(Exprs.Finals);

2263 Dir->setPreInits(Exprs.PreInits);

2273 return Dir;

2274}

2275

2278 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,

2280 return createEmptyDirective(

2281 C, NumClauses, true,

2283 OMPD_target_teams_distribute_parallel_for_simd),

2284 CollapsedNum);

2285}

2286

2292 auto *Dir = createDirective(

2293 C, Clauses, AssociatedStmt,

2294 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),

2295 StartLoc, EndLoc, CollapsedNum);

2299 Dir->setPreCond(Exprs.PreCond);

2300 Dir->setCond(Exprs.Cond);

2301 Dir->setInit(Exprs.Init);

2302 Dir->setInc(Exprs.Inc);

2303 Dir->setIsLastIterVariable(Exprs.IL);

2304 Dir->setLowerBoundVariable(Exprs.LB);

2305 Dir->setUpperBoundVariable(Exprs.UB);

2306 Dir->setStrideVariable(Exprs.ST);

2307 Dir->setEnsureUpperBound(Exprs.EUB);

2308 Dir->setNextLowerBound(Exprs.NLB);

2309 Dir->setNextUpperBound(Exprs.NUB);

2311 Dir->setCounters(Exprs.Counters);

2313 Dir->setInits(Exprs.Inits);

2314 Dir->setUpdates(Exprs.Updates);

2315 Dir->setFinals(Exprs.Finals);

2319 Dir->setPreInits(Exprs.PreInits);

2320 return Dir;

2321}

2322

2325 unsigned NumClauses,

2326 unsigned CollapsedNum,

2328 return createEmptyDirective(

2329 C, NumClauses, true,

2330 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),

2331 CollapsedNum);

2332}

2333

2338 return createDirective(

2339 C, Clauses, nullptr, 0, StartLoc,

2340 EndLoc);

2341}

2342

2344 unsigned NumClauses,

2346 return createEmptyDirective(C, NumClauses);

2347}

2348

2353 auto *Dir = createDirective(

2354 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);

2355 Dir->setTargetCallLoc(TargetCallLoc);

2356 return Dir;

2357}

2358

2360 unsigned NumClauses,

2362 return createEmptyDirective(C, NumClauses,

2363 true,

2364 0);

2365}

2366

2371 Stmt *AssociatedStmt) {

2372 return createDirective(C, Clauses, AssociatedStmt,

2373 0, StartLoc,

2374 EndLoc);

2375}

2376

2378 unsigned NumClauses,

2380 return createEmptyDirective(C, NumClauses,

2381 true);

2382}

2383

2388 auto *Dir = createDirective(

2389 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_loop),

2390 StartLoc, EndLoc, CollapsedNum);

2394 Dir->setPreCond(Exprs.PreCond);

2395 Dir->setCond(Exprs.Cond);

2396 Dir->setInit(Exprs.Init);

2397 Dir->setInc(Exprs.Inc);

2398 Dir->setIsLastIterVariable(Exprs.IL);

2399 Dir->setLowerBoundVariable(Exprs.LB);

2400 Dir->setUpperBoundVariable(Exprs.UB);

2401 Dir->setStrideVariable(Exprs.ST);

2402 Dir->setEnsureUpperBound(Exprs.EUB);

2403 Dir->setNextLowerBound(Exprs.NLB);

2404 Dir->setNextUpperBound(Exprs.NUB);

2406 Dir->setCounters(Exprs.Counters);

2408 Dir->setInits(Exprs.Inits);

2409 Dir->setUpdates(Exprs.Updates);

2410 Dir->setFinals(Exprs.Finals);

2414 Dir->setPreInits(Exprs.PreInits);

2415 return Dir;

2416}

2417

2420 unsigned CollapsedNum, EmptyShell) {

2421 return createEmptyDirective(

2422 C, NumClauses, true,

2423 numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum);

2424}

2425

2430 auto *Dir = createDirective(

2431 C, Clauses, AssociatedStmt,

2432 numLoopChildren(CollapsedNum, OMPD_teams_loop), StartLoc, EndLoc,

2433 CollapsedNum);

2437 Dir->setPreCond(Exprs.PreCond);

2438 Dir->setCond(Exprs.Cond);

2439 Dir->setInit(Exprs.Init);

2440 Dir->setInc(Exprs.Inc);

2441 Dir->setIsLastIterVariable(Exprs.IL);

2442 Dir->setLowerBoundVariable(Exprs.LB);

2443 Dir->setUpperBoundVariable(Exprs.UB);

2444 Dir->setStrideVariable(Exprs.ST);

2445 Dir->setEnsureUpperBound(Exprs.EUB);

2446 Dir->setNextLowerBound(Exprs.NLB);

2447 Dir->setNextUpperBound(Exprs.NUB);

2449 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2450 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2451 Dir->setDistInc(Exprs.DistInc);

2452 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2453 Dir->setCounters(Exprs.Counters);

2455 Dir->setInits(Exprs.Inits);

2456 Dir->setUpdates(Exprs.Updates);

2457 Dir->setFinals(Exprs.Finals);

2461 Dir->setPreInits(Exprs.PreInits);

2471 return Dir;

2472}

2473

2476 unsigned NumClauses,

2477 unsigned CollapsedNum, EmptyShell) {

2478 return createEmptyDirective(

2479 C, NumClauses, true,

2480 numLoopChildren(CollapsedNum, OMPD_teams_loop), CollapsedNum);

2481}

2482

2486 const HelperExprs &Exprs, bool CanBeParallelFor) {

2487 auto *Dir = createDirective(

2488 C, Clauses, AssociatedStmt,

2489 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), StartLoc, EndLoc,

2490 CollapsedNum);

2494 Dir->setPreCond(Exprs.PreCond);

2495 Dir->setCond(Exprs.Cond);

2496 Dir->setInit(Exprs.Init);

2497 Dir->setInc(Exprs.Inc);

2498 Dir->setIsLastIterVariable(Exprs.IL);

2499 Dir->setLowerBoundVariable(Exprs.LB);

2500 Dir->setUpperBoundVariable(Exprs.UB);

2501 Dir->setStrideVariable(Exprs.ST);

2502 Dir->setEnsureUpperBound(Exprs.EUB);

2503 Dir->setNextLowerBound(Exprs.NLB);

2504 Dir->setNextUpperBound(Exprs.NUB);

2506 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);

2507 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);

2508 Dir->setDistInc(Exprs.DistInc);

2509 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);

2510 Dir->setCounters(Exprs.Counters);

2512 Dir->setInits(Exprs.Inits);

2513 Dir->setUpdates(Exprs.Updates);

2514 Dir->setFinals(Exprs.Finals);

2518 Dir->setPreInits(Exprs.PreInits);

2528 Dir->setCanBeParallelFor(CanBeParallelFor);

2529 return Dir;

2530}

2531

2534 unsigned NumClauses,

2535 unsigned CollapsedNum,

2537 return createEmptyDirective(

2538 C, NumClauses, true,

2539 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), CollapsedNum);

2540}

2541

2546 auto *Dir = createDirective(

2547 C, Clauses, AssociatedStmt,

2548 numLoopChildren(CollapsedNum, OMPD_parallel_loop), StartLoc, EndLoc,

2549 CollapsedNum);

2553 Dir->setPreCond(Exprs.PreCond);

2554 Dir->setCond(Exprs.Cond);

2555 Dir->setInit(Exprs.Init);

2556 Dir->setInc(Exprs.Inc);

2557 Dir->setIsLastIterVariable(Exprs.IL);

2558 Dir->setLowerBoundVariable(Exprs.LB);

2559 Dir->setUpperBoundVariable(Exprs.UB);

2560 Dir->setStrideVariable(Exprs.ST);

2561 Dir->setEnsureUpperBound(Exprs.EUB);

2562 Dir->setNextLowerBound(Exprs.NLB);

2563 Dir->setNextUpperBound(Exprs.NUB);

2565 Dir->setCounters(Exprs.Counters);

2567 Dir->setInits(Exprs.Inits);

2568 Dir->setUpdates(Exprs.Updates);

2569 Dir->setFinals(Exprs.Finals);

2573 Dir->setPreInits(Exprs.PreInits);

2574 return Dir;

2575}

2576

2578 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,

2580 return createEmptyDirective(

2581 C, NumClauses, true,

2582 numLoopChildren(CollapsedNum, OMPD_parallel_loop), CollapsedNum);

2583}

2584

2590 auto *Dir = createDirective(

2591 C, Clauses, AssociatedStmt,

2592 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), StartLoc,

2593 EndLoc, CollapsedNum);

2597 Dir->setPreCond(Exprs.PreCond);

2598 Dir->setCond(Exprs.Cond);

2599 Dir->setInit(Exprs.Init);

2600 Dir->setInc(Exprs.Inc);

2601 Dir->setIsLastIterVariable(Exprs.IL);

2602 Dir->setLowerBoundVariable(Exprs.LB);

2603 Dir->setUpperBoundVariable(Exprs.UB);

2604 Dir->setStrideVariable(Exprs.ST);

2605 Dir->setEnsureUpperBound(Exprs.EUB);

2606 Dir->setNextLowerBound(Exprs.NLB);

2607 Dir->setNextUpperBound(Exprs.NUB);

2609 Dir->setCounters(Exprs.Counters);

2611 Dir->setInits(Exprs.Inits);

2612 Dir->setUpdates(Exprs.Updates);

2613 Dir->setFinals(Exprs.Finals);

2617 Dir->setPreInits(Exprs.PreInits);

2618 return Dir;

2619}

2620

2623 unsigned NumClauses,

2624 unsigned CollapsedNum,

2626 return createEmptyDirective(

2627 C, NumClauses, true,

2628 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), CollapsedNum);

2629}

Defines the clang::ASTContext interface.

This file defines OpenMP AST classes for executable directives and clauses.

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

This represents one expression.

IfStmt - This represents an if/then/else.

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

static OMPAssumeDirective * Create(const ASTContext &Ctx, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AStmt)

This represents '#pragma omp atomic' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expressions Exprs)

Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...

This represents '#pragma omp barrier' directive.

static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)

Creates directive.

static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)

Creates an empty directive.

This represents '#pragma omp cancel' directive.

static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)

Creates directive.

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

Creates an empty directive.

This represents '#pragma omp cancellation point' directive.

static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)

Creates an empty directive.

static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)

Creates directive.

Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...

void setClauses(ArrayRef< OMPClause * > Clauses)

Sets the list of variables for this clause.

MutableArrayRef< Stmt * > getChildren()

This represents '#pragma omp critical' directive.

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

Creates an empty directive.

static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive.

This represents '#pragma omp depobj' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPDepobjDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

Creates directive with a list of Clauses.

This represents '#pragma omp dispatch' directive.

static OMPDispatchDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, SourceLocation TargetCallLoc)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp distribute' directive.

static OMPDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp distribute parallel for' composite directive.

static OMPDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

This represents '#pragma omp distribute parallel for simd' composite directive.

static OMPDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp distribute simd' composite directive.

static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp error' directive.

static OMPErrorDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

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

Creates an empty directive.

bool hasAssociatedStmt() const

Returns true if directive has associated statement.

const Stmt * getRawStmt() const

OMPChildren * Data

Data, associated with the directive.

const Stmt * getStructuredBlock() const

Returns the AST node representing OpenMP structured-block of this OpenMP executable directive,...

bool isStandaloneDirective() const

Returns whether or not this is a Standalone directive.

This represents '#pragma omp flush' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

Creates directive with a list of Clauses.

This represents '#pragma omp for' directive.

static OMPForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp for simd' directive.

static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp loop' directive.

static OMPGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with a place for NumClauses clauses.

static OMPGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

Represents the '#pragma omp interchange' loop transformation directive.

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

Build an empty '#pragma omp interchange' AST node for deserialization.

static OMPInterchangeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)

Create a new AST node representation for '#pragma omp interchange'.

This represents '#pragma omp interop' directive.

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

Creates an empty directive.

static OMPInteropDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

Creates directive.

static void doForAllLoopsBodies(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< void(unsigned, Stmt *, Stmt *)> Callback)

Calls the specified callback function for all the loop bodies in CurStmt, from the outermost loop to ...

unsigned NumAssociatedLoops

Number of collapsed loops as specified by 'collapse' clause.

static Stmt * tryToFindNextInnerLoop(Stmt *CurStmt, bool TryImperfectlyNestedLoops)

Try to find the next loop sub-statement in the specified statement CurStmt.

static bool doForAllLoops(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< bool(unsigned, Stmt *)> Callback, llvm::function_ref< void(OMPLoopTransformationDirective *)> OnTransformationCallback)

Calls the specified callback function for all the loops in CurStmt, from the outermost to the innermo...

unsigned getLoopsNumber() const

Get number of collapsed loops.

void setFinals(ArrayRef< Expr * > A)

void setDependentCounters(ArrayRef< Expr * > A)

void setFinalsConditions(ArrayRef< Expr * > A)

void setInits(ArrayRef< Expr * > A)

static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)

Children number.

void setCounters(ArrayRef< Expr * > A)

void setDependentInits(ArrayRef< Expr * > A)

void setUpdates(ArrayRef< Expr * > A)

void setPrivateCounters(ArrayRef< Expr * > A)

The base class for all loop transformation directives.

Stmt * getPreInits() const

Return preinits statement.

Stmt * getTransformedStmt() const

Get the de-sugared statements after the loop transformation.

This represents '#pragma omp masked' directive.

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

Creates an empty directive.

static OMPMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive.

This represents '#pragma omp masked taskloop' directive.

static OMPMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)

Creates directive with a list of Clauses.

static OMPMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp masked taskloop simd' directive.

static OMPMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp master' directive.

static OMPMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)

Creates directive.

static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)

Creates an empty directive.

This represents '#pragma omp master taskloop' directive.

static OMPMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)

Creates directive with a list of Clauses.

static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp master taskloop simd' directive.

static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp ordered' directive.

static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive.

static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)

Creates an empty directive.

This represents '#pragma omp parallel' directive.

static OMPParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for N clauses.

This represents '#pragma omp parallel for' directive.

static OMPParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel for simd' directive.

static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp parallel loop' directive.

static OMPParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp parallel masked' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPParallelMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)

Creates directive with a list of Clauses.

This represents '#pragma omp parallel masked taskloop' directive.

static OMPParallelMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)

Creates directive with a list of Clauses.

static OMPParallelMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel masked taskloop simd' directive.

static OMPParallelMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPParallelMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel master' directive.

static OMPParallelMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel master taskloop' directive.

static OMPParallelMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)

Creates directive with a list of Clauses.

static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel master taskloop simd' directive.

static OMPParallelMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPParallelMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp parallel sections' directive.

static OMPParallelSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

Represents the '#pragma omp reverse' loop transformation directive.

static OMPReverseDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)

Create a new AST node representation for '#pragma omp reverse'.

static OMPReverseDirective * CreateEmpty(const ASTContext &C)

Build an empty '#pragma omp reverse' AST node for deserialization.

This represents '#pragma omp scan' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPScanDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

Creates directive with a list of Clauses.

This represents '#pragma omp scope' directive.

static OMPScopeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive.

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

Creates an empty directive.

This represents '#pragma omp section' directive.

static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)

Creates an empty directive.

void setHasCancel(bool Has)

Set cancel state.

static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)

Creates directive.

This represents '#pragma omp sections' directive.

static OMPSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp simd' directive.

static OMPSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp single' directive.

static OMPSingleDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target data' directive.

static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)

Creates an empty directive with the place for N clauses.

static OMPTargetDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

This represents '#pragma omp target' directive.

static OMPTargetDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target enter data' directive.

static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)

Creates an empty directive with the place for N clauses.

This represents '#pragma omp target exit data' directive.

static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)

Creates an empty directive with the place for N clauses.

This represents '#pragma omp target parallel' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

This represents '#pragma omp target parallel for' directive.

static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

This represents '#pragma omp target parallel for simd' directive.

static OMPTargetParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target parallel loop' directive.

static OMPTargetParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp target simd' directive.

static OMPTargetSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target teams' directive.

static OMPTargetTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

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

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target teams distribute' combined directive.

static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp target teams distribute parallel for' combined directive.

static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

This represents '#pragma omp target teams distribute parallel for simd' combined directive.

static OMPTargetTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTargetTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target teams distribute simd' combined directive.

static OMPTargetTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target teams loop' directive.

static OMPTargetTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool CanBeParallelFor)

Creates directive with a list of Clauses.

static OMPTargetTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp target update' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

This represents '#pragma omp task' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPTaskDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)

Creates directive with a list of Clauses.

This represents '#pragma omp taskloop' directive.

static OMPTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)

Creates directive with a list of Clauses.

static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp taskloop simd' directive.

static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents '#pragma omp taskgroup' directive.

static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *ReductionRef)

Creates directive.

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

Creates an empty directive.

This represents '#pragma omp taskwait' directive.

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

Creates an empty directive.

static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)

Creates directive.

This represents '#pragma omp taskyield' directive.

static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)

Creates an empty directive.

static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)

Creates directive.

This represents '#pragma omp teams' directive.

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

Creates an empty directive with the place for NumClauses clauses.

static OMPTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)

Creates directive with a list of Clauses.

This represents '#pragma omp teams distribute' directive.

static OMPTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp teams distribute parallel for' composite directive.

static OMPTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)

Creates directive with a list of Clauses.

static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp teams distribute parallel for simd' composite directive.

static OMPTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp teams distribute simd' combined directive.

static OMPTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

This represents '#pragma omp teams loop' directive.

static OMPTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)

Creates an empty directive with the place for NumClauses clauses.

static OMPTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)

Creates directive with a list of Clauses.

This represents the '#pragma omp tile' loop transformation directive.

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

Build an empty '#pragma omp tile' AST node for deserialization.

static OMPTileDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)

Create a new AST node representation for '#pragma omp tile'.

This represents the '#pragma omp unroll' loop transformation directive.

static OMPUnrollDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, unsigned NumGeneratedLoops, Stmt *TransformedStmt, Stmt *PreInits)

Create a new AST node representation for '#pragma omp unroll'.

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

Build an empty '#pragma omp unroll' AST node for deserialization.

Encodes a location in the source.

Stmt - This represents one statement.

StmtClass getStmtClass() const

Stmt * IgnoreContainers(bool IgnoreCaptured=false)

Skip no-op (attributed, compound) container stmts and skip captured stmt at the top,...

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

llvm::omp::Directive OpenMPDirectiveKind

OpenMP directives.

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

Expr * E

'expr' part of the associated expression/statement.

Expr * D

'd' part of the associated expression/statement.

Expr * UE

UE Helper expression of the form: 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 'OpaqueValueExp...

bool IsFailOnly

True if 'v' is updated only when the condition is false (compare capture only).

Expr * X

'x' part of the associated expression/statement.

Expr * Cond

Conditional expression in atomic compare construct.

Expr * V

'v' part of the associated expression/statement.

bool IsPostfixUpdate

True if original value of 'x' must be stored in 'v', not an updated one.

bool IsXLHSInRHSPart

True if UE has the first form and false if the second.

Expr * ParForInDistCond

'omp parallel for' loop condition used when composed with 'omp distribute' in the same construct and ...

Expr * LB

DistributeLowerBound - used when composing 'omp distribute' with 'omp for' in a same construct.

Expr * Init

Distribute loop iteration variable init used when composing 'omp distribute' with 'omp for' in a same...

Expr * NUB

Update of UpperBound for statically scheduled omp loops for outer loop in combined constructs (e....

Expr * EUB

DistributeEnsureUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct,...

Expr * UB

DistributeUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct.

Expr * NLB

Update of LowerBound for statically scheduled omp loops for outer loop in combined constructs (e....

Expr * DistCond

Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct whe...

Expr * Cond

Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct.

The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.

Expr * LastIteration

Loop last iteration number.

Expr * Cond

Loop condition.

SmallVector< Expr *, 4 > DependentInits

List of initializers required for the generation of the non-rectangular loops.

SmallVector< Expr *, 4 > Inits

Expressions for loop counters inits for CodeGen.

Expr * PrevEUB

PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e....

Expr * DistInc

DistInc - increment expression for distribute loop when found combined with a further loop level (e....

Expr * IL

IsLastIteration - local flag variable passed to runtime.

SmallVector< Expr *, 4 > PrivateCounters

PrivateCounters Loop counters.

Expr * CalcLastIteration

Calculation of last iteration.

SmallVector< Expr *, 4 > Updates

Expressions for loop counters update for CodeGen.

Expr * ST

Stride - local variable passed to runtime.

SmallVector< Expr *, 4 > Finals

Final loop counter values for GodeGen.

SmallVector< Expr *, 4 > FinalsConditions

List of final conditions required for the generation of the non-rectangular loops.

Expr * PreCond

Loop pre-condition.

Stmt * PreInits

Init statement for all captured expressions.

Expr * IterationVarRef

Loop iteration variable.

Expr * NumIterations

Loop number of iterations.

SmallVector< Expr *, 4 > Counters

Counters Loop counters.

Expr * NLB

Update of LowerBound for statically scheduled 'omp for' loops.

Expr * PrevUB

PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...

DistCombinedHelperExprs DistCombinedFields

Expressions used when combining OpenMP loop pragmas.

Expr * Inc

Loop increment.

Expr * EUB

EnsureUpperBound – expression UB = min(UB, NumIterations).

Expr * UB

UpperBound - local variable passed to runtime.

Expr * NUB

Update of UpperBound for statically scheduled 'omp for' loops.

Expr * LB

LowerBound - local variable passed to runtime.

Expr * PrevLB

PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...

SmallVector< Expr *, 4 > DependentCounters

List of counters required for the generation of the non-rectangular loops.

Expr * Init

Loop iteration variable init.

A placeholder type used to construct an empty shell of a type, that will be filled in later (e....