llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-flang-openmp Author: Julian Brown (jtb20) <details> <summary>Changes</summary> This is a version of the `ompx taskgraph` support posted in [PR66919](https://github.com/llvm/llvm-project/pull/66919), adapted to the official OpenMP 6.0 spelling of `omp taskgraph`, and with the `ompx` extension parts removed. I've merged the changes to the current mainline, tidied up the patch series and adjusted tests a little, but other than that I've not done much testing, so support should still be considered experimental. See also https://github.com/llvm/llvm-project/issues/130926. --- Patch is 63.84 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/159774.diff 47 Files Affected: - (modified) clang/include/clang-c/Index.h (+5-1) - (modified) clang/include/clang/AST/RecursiveASTVisitor.h (+3) - (modified) clang/include/clang/AST/StmtOpenMP.h (+49) - (modified) clang/include/clang/Basic/StmtNodes.td (+1) - (modified) clang/include/clang/Sema/SemaOpenMP.h (+4) - (modified) clang/include/clang/Serialization/ASTBitCodes.h (+1) - (modified) clang/lib/AST/StmtOpenMP.cpp (+15) - (modified) clang/lib/AST/StmtPrinter.cpp (+4) - (modified) clang/lib/AST/StmtProfile.cpp (+5) - (modified) clang/lib/Basic/OpenMPKinds.cpp (+3) - (modified) clang/lib/CodeGen/CGOpenMPRuntime.cpp (+74) - (modified) clang/lib/CodeGen/CGOpenMPRuntime.h (+8) - (modified) clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp (+2) - (modified) clang/lib/CodeGen/CGStmt.cpp (+3) - (modified) clang/lib/CodeGen/CGStmtOpenMP.cpp (+6) - (modified) clang/lib/CodeGen/CodeGenFunction.h (+1) - (modified) clang/lib/Sema/SemaExceptionSpec.cpp (+1) - (modified) clang/lib/Sema/SemaOpenMP.cpp (+32) - (modified) clang/lib/Sema/TreeTransform.h (+11) - (modified) clang/lib/Serialization/ASTReaderStmt.cpp (+10) - (modified) clang/lib/Serialization/ASTWriterStmt.cpp (+6) - (modified) clang/lib/StaticAnalyzer/Core/ExprEngine.cpp (+1) - (modified) clang/tools/libclang/CIndex.cpp (+2) - (modified) clang/tools/libclang/CXCursor.cpp (+3) - (modified) llvm/include/llvm/Frontend/OpenMP/OMPKinds.def (+1) - (modified) openmp/runtime/CMakeLists.txt (+4-4) - (modified) openmp/runtime/src/kmp.h (+9-6) - (modified) openmp/runtime/src/kmp_config.h.cmake (+2-2) - (modified) openmp/runtime/src/kmp_global.cpp (+2-2) - (modified) openmp/runtime/src/kmp_settings.cpp (+2-2) - (modified) openmp/runtime/src/kmp_taskdeps.cpp (+8-8) - (modified) openmp/runtime/src/kmp_taskdeps.h (+2-2) - (modified) openmp/runtime/src/kmp_tasking.cpp (+75-48) - (modified) openmp/runtime/test/CMakeLists.txt (+1-1) - (modified) openmp/runtime/test/lit.cfg (+2-2) - (modified) openmp/runtime/test/lit.site.cfg.in (+1-1) - (modified) openmp/runtime/test/tasking/omp_record_replay.cpp (+1-1) - (modified) openmp/runtime/test/tasking/omp_record_replay_deps.cpp (+1-1) - (modified) openmp/runtime/test/tasking/omp_record_replay_deps_multi_succ.cpp (+1-1) - (modified) openmp/runtime/test/tasking/omp_record_replay_multiTDGs.cpp (+1-1) - (modified) openmp/runtime/test/tasking/omp_record_replay_print_dot.cpp (+19-30) - (modified) openmp/runtime/test/tasking/omp_record_replay_taskloop.cpp (+1-1) - (added) openmp/runtime/test/tasking/omp_taskgraph.cpp (+37) - (added) openmp/runtime/test/tasking/omp_taskgraph_deps.cpp (+52) - (added) openmp/runtime/test/tasking/omp_taskgraph_multiTDGs.cpp (+66) - (added) openmp/runtime/test/tasking/omp_taskgraph_print_dot.cpp (+58) - (added) openmp/runtime/test/tasking/omp_taskgraph_taskloop.cpp (+39) ``````````diff diff --git a/clang/include/clang-c/Index.h b/clang/include/clang-c/Index.h index be038d9165fc6..4bf1501e27382 100644 --- a/clang/include/clang-c/Index.h +++ b/clang/include/clang-c/Index.h @@ -2218,7 +2218,11 @@ enum CXCursorKind { */ CXCursor_OpenACCCacheConstruct = 333, - CXCursor_LastStmt = CXCursor_OpenACCCacheConstruct, + /** OpenMP taskgraph directive. + */ + CXCursor_OMPTaskgraphDirective = 334, + + CXCursor_LastStmt = CXCursor_OMPTaskgraphDirective, /** * Cursor that represents the translation unit itself. diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index 1d1b7f183f75a..516ddbe62c9d9 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -3232,6 +3232,9 @@ DEF_TRAVERSE_STMT(OMPBarrierDirective, DEF_TRAVERSE_STMT(OMPTaskwaitDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPTaskgraphDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + DEF_TRAVERSE_STMT(OMPTaskgroupDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) diff --git a/clang/include/clang/AST/StmtOpenMP.h b/clang/include/clang/AST/StmtOpenMP.h index d9f87f1e49b40..3750ccae41fb4 100644 --- a/clang/include/clang/AST/StmtOpenMP.h +++ b/clang/include/clang/AST/StmtOpenMP.h @@ -2729,6 +2729,55 @@ class OMPTaskwaitDirective : public OMPExecutableDirective { } }; +/// This represents '#pragma omp taskgraph' directive. +/// Available with OpenMP 6.0. +/// +/// \code +/// #pragma omp taskgraph +/// \endcode +/// +class OMPTaskgraphDirective final : public OMPExecutableDirective { + friend class ASTStmtReader; + friend class OMPExecutableDirective; + /// Build directive with the given start and end location. + /// + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending location of the directive. + /// + OMPTaskgraphDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(OMPTaskgraphDirectiveClass, + llvm::omp::OMPD_taskgraph, StartLoc, EndLoc) {} + + /// Build an empty directive. + /// + explicit OMPTaskgraphDirective() + : OMPExecutableDirective(OMPTaskgraphDirectiveClass, + llvm::omp::OMPD_taskgraph, SourceLocation(), + SourceLocation()) {} + +public: + /// Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// + static OMPTaskgraphDirective * + Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt); + + /// Creates an empty directive. + /// + /// \param C AST context. + /// + static OMPTaskgraphDirective *CreateEmpty(const ASTContext &C, + unsigned NumClauses, EmptyShell); + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPTaskgraphDirectiveClass; + } +}; + /// This represents '#pragma omp taskgroup' directive. /// /// \code diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td index dd1a24405fae7..7fa54727de14c 100644 --- a/clang/include/clang/Basic/StmtNodes.td +++ b/clang/include/clang/Basic/StmtNodes.td @@ -253,6 +253,7 @@ def OMPTaskDirective : StmtNode<OMPExecutableDirective>; def OMPTaskyieldDirective : StmtNode<OMPExecutableDirective>; def OMPBarrierDirective : StmtNode<OMPExecutableDirective>; def OMPTaskwaitDirective : StmtNode<OMPExecutableDirective>; +def OMPTaskgraphDirective : StmtNode<OMPExecutableDirective>; def OMPTaskgroupDirective : StmtNode<OMPExecutableDirective>; def OMPFlushDirective : StmtNode<OMPExecutableDirective>; def OMPDepobjDirective : StmtNode<OMPExecutableDirective>; diff --git a/clang/include/clang/Sema/SemaOpenMP.h b/clang/include/clang/Sema/SemaOpenMP.h index c0fd7a6d63611..2aafaac3ac3f8 100644 --- a/clang/include/clang/Sema/SemaOpenMP.h +++ b/clang/include/clang/Sema/SemaOpenMP.h @@ -550,6 +550,10 @@ class SemaOpenMP : public SemaBase { /// Called on well-formed '\#pragma omp barrier'. StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc, SourceLocation EndLoc); + /// Called on well-formed '\#pragma omp taskgraph'. + StmtResult ActOnOpenMPTaskgraphDirective(ArrayRef<OMPClause *> Clauses, + Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc); /// Called on well-formed '\#pragma omp taskwait'. StmtResult ActOnOpenMPTaskwaitDirective(ArrayRef<OMPClause *> Clauses, SourceLocation StartLoc, diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h index 441047d64f48c..09432273834d1 100644 --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -1968,6 +1968,7 @@ enum StmtCode { STMT_OMP_ERROR_DIRECTIVE, STMT_OMP_BARRIER_DIRECTIVE, STMT_OMP_TASKWAIT_DIRECTIVE, + STMT_OMP_TASKGRAPH_DIRECTIVE, STMT_OMP_FLUSH_DIRECTIVE, STMT_OMP_DEPOBJ_DIRECTIVE, STMT_OMP_SCAN_DIRECTIVE, diff --git a/clang/lib/AST/StmtOpenMP.cpp b/clang/lib/AST/StmtOpenMP.cpp index 1f6586f95a9f8..4fafedfb8602c 100644 --- a/clang/lib/AST/StmtOpenMP.cpp +++ b/clang/lib/AST/StmtOpenMP.cpp @@ -882,6 +882,21 @@ OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, return createEmptyDirective<OMPTaskwaitDirective>(C, NumClauses); } +OMPTaskgraphDirective *OMPTaskgraphDirective::Create( + const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { + auto *Dir = createDirective<OMPTaskgraphDirective>( + C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); + return Dir; +} + +OMPTaskgraphDirective *OMPTaskgraphDirective::CreateEmpty(const ASTContext &C, + unsigned NumClauses, + EmptyShell) { + return createEmptyDirective<OMPTaskgraphDirective>( + C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); +} + OMPTaskgroupDirective *OMPTaskgroupDirective::Create( const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) { diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp index 0030300521128..a9e42d50e3ea8 100644 --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -891,6 +891,10 @@ void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) { void StmtPrinter::VisitOMPAssumeDirective(OMPAssumeDirective *Node) { Indent() << "#pragma omp assume"; +} + +void StmtPrinter::VisitOMPTaskgraphDirective(OMPTaskgraphDirective *Node) { + Indent() << "#pragma omp taskgraph"; PrintOMPExecutableDirective(Node); } diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index 37c4d43ec0b2f..f08a2da81325f 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -1103,9 +1103,14 @@ void StmtProfiler::VisitOMPAssumeDirective(const OMPAssumeDirective *S) { VisitOMPExecutableDirective(S); } +void StmtProfiler::VisitOMPTaskgraphDirective(const OMPTaskgraphDirective *S) { + VisitOMPExecutableDirective(S); +} + void StmtProfiler::VisitOMPErrorDirective(const OMPErrorDirective *S) { VisitOMPExecutableDirective(S); } + void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) { VisitOMPExecutableDirective(S); if (const Expr *E = S->getReductionRef()) diff --git a/clang/lib/Basic/OpenMPKinds.cpp b/clang/lib/Basic/OpenMPKinds.cpp index 508685883364c..8a0466b354f4d 100644 --- a/clang/lib/Basic/OpenMPKinds.cpp +++ b/clang/lib/Basic/OpenMPKinds.cpp @@ -869,6 +869,9 @@ void clang::getOpenMPCaptureRegions( case OMPD_taskloop: CaptureRegions.push_back(OMPD_taskloop); break; + case OMPD_taskgraph: + CaptureRegions.push_back(OMPD_taskgraph); + break; case OMPD_loop: // TODO: 'loop' may require different capture regions depending on the // bind clause or the parent directive when there is no bind clause. diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp index a503aaf613e30..91f9254c662d9 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp @@ -58,6 +58,8 @@ class CGOpenMPRegionInfo : public CodeGenFunction::CGCapturedStmtInfo { ParallelOutlinedRegion, /// Region with outlined function for standalone 'task' directive. TaskOutlinedRegion, + /// Region with outlined function for standalone 'taskgraph' directive. + TaskgraphOutlinedRegion, /// Region for constructs that do not require function outlining, /// like 'for', 'sections', 'atomic' etc. directives. InlinedRegion, @@ -232,6 +234,26 @@ class CGOpenMPTaskOutlinedRegionInfo final : public CGOpenMPRegionInfo { const UntiedTaskActionTy &Action; }; +/// API for captured statement code generation in OpenMP taskgraphs. +class CGOpenMPTaskgraphRegionInfo final : public CGOpenMPRegionInfo { +public: + CGOpenMPTaskgraphRegionInfo(const CapturedStmt &CS, + const RegionCodeGenTy &CodeGen) + : CGOpenMPRegionInfo(CS, TaskgraphOutlinedRegion, CodeGen, + llvm::omp::OMPD_taskgraph, false) {} + + const VarDecl *getThreadIDVariable() const override { return 0; } + + /// Get the name of the capture helper. + StringRef getHelperName() const override { return "taskgraph.omp_outlined."; } + + static bool classof(const CGCapturedStmtInfo *Info) { + return CGOpenMPRegionInfo::classof(Info) && + cast<CGOpenMPRegionInfo>(Info)->getRegionKind() == + TaskgraphOutlinedRegion; + } +}; + /// API for inlined captured statement code generation in OpenMP /// constructs. class CGOpenMPInlinedRegionInfo : public CGOpenMPRegionInfo { @@ -5954,6 +5976,48 @@ void CGOpenMPRuntime::emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, Region->emitUntiedSwitch(CGF); } +void CGOpenMPRuntime::emitTaskgraphCall(CodeGenFunction &CGF, + SourceLocation Loc, + const OMPExecutableDirective &D) { + if (!CGF.HaveInsertPoint()) + return; + + // Building kmp_taskgraph_flags_t flags for kmpc_taskgraph. C.f., kmp.h + enum { + NowaitFlag = 0x1, // Not used yet. + ReRecordFlag = 0x2, + }; + + unsigned Flags = 0; + + CodeGenFunction OutlinedCGF(CGM, true); + + const CapturedStmt *CS = cast<CapturedStmt>(D.getAssociatedStmt()); + + auto &&BodyGen = [CS](CodeGenFunction &CGF, PrePostActionTy &) { + CGF.EmitStmt(CS->getCapturedStmt()); + }; + + LValue CapStruct = CGF.InitCapturedStruct(*CS); + CGOpenMPTaskgraphRegionInfo TaskgraphRegion(*CS, BodyGen); + CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(OutlinedCGF, + &TaskgraphRegion); + llvm::Function *FnT = OutlinedCGF.GenerateCapturedStmtFunction(*CS); + + std::vector<llvm::Value *> Args{ + emitUpdateLocation(CGF, Loc), + getThreadID(CGF, Loc), + CGF.Builder.getInt32(Flags), + CGF.Builder.getInt32(D.getBeginLoc().getHashValue()), + CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(FnT, CGM.VoidPtrTy), + CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( + CapStruct.getPointer(OutlinedCGF), CGM.VoidPtrTy)}; + + CGF.EmitRuntimeCall(OMPBuilder.getOrCreateRuntimeFunction( + CGM.getModule(), OMPRTL___kmpc_taskgraph), + Args); +} + void CGOpenMPRuntime::emitInlinedDirective(CodeGenFunction &CGF, OpenMPDirectiveKind InnerKind, const RegionCodeGenTy &CodeGen, @@ -6389,6 +6453,7 @@ const Expr *CGOpenMPRuntime::getNumTeamsExprForTargetDirective( case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: @@ -9402,6 +9467,7 @@ getNestedDistributeDirective(ASTContext &Ctx, const OMPExecutableDirective &D) { case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: @@ -10048,6 +10114,7 @@ void CGOpenMPRuntime::scanForTargetRegionsFunctions(const Stmt *S, case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: @@ -10615,6 +10682,7 @@ void CGOpenMPRuntime::emitTargetDataStandAloneCall( case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: @@ -12355,6 +12423,12 @@ void CGOpenMPSIMDRuntime::emitTaskwaitCall(CodeGenFunction &CGF, llvm_unreachable("Not supported in SIMD-only mode"); } +void CGOpenMPSIMDRuntime::emitTaskgraphCall(CodeGenFunction &CGF, + SourceLocation Loc, + const OMPExecutableDirective &D) { + llvm_unreachable("Not supported in SIMD-only mode"); +} + void CGOpenMPSIMDRuntime::emitCancellationPointCall( CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion) { diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.h b/clang/lib/CodeGen/CGOpenMPRuntime.h index eb04eceee236c..7e8dc651a5b9a 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.h +++ b/clang/lib/CodeGen/CGOpenMPRuntime.h @@ -1360,6 +1360,10 @@ class CGOpenMPRuntime { virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data); + /// Emit code for 'taskgraph' directive. + virtual void emitTaskgraphCall(CodeGenFunction &CGF, SourceLocation Loc, + const OMPExecutableDirective &D); + /// Emit code for 'cancellation point' construct. /// \param CancelRegion Region kind for which the cancellation point must be /// emitted. @@ -2186,6 +2190,10 @@ class CGOpenMPSIMDRuntime final : public CGOpenMPRuntime { void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc, const OMPTaskDataTy &Data) override; + /// Emit code for 'taskgraph' directive. + void emitTaskgraphCall(CodeGenFunction &CGF, SourceLocation Loc, + const OMPExecutableDirective &D) override; + /// Emit code for 'cancellation point' construct. /// \param CancelRegion Region kind for which the cancellation point must be /// emitted. diff --git a/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp b/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp index 44a091e1b3c75..03eef1bf44a6d 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp @@ -572,6 +572,7 @@ static bool hasNestedSPMDDirective(ASTContext &Ctx, case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: @@ -660,6 +661,7 @@ static bool supportsSPMDExecutionMode(ASTContext &Ctx, case OMPD_taskyield: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_atomic: case OMPD_flush: diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp index aeff73d525c10..d18832e74ca35 100644 --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -282,6 +282,9 @@ void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs) { case Stmt::OMPTaskwaitDirectiveClass: EmitOMPTaskwaitDirective(cast<OMPTaskwaitDirective>(*S)); break; + case Stmt::OMPTaskgraphDirectiveClass: + EmitOMPTaskgraphDirective(cast<OMPTaskgraphDirective>(*S)); + break; case Stmt::OMPTaskgroupDirectiveClass: EmitOMPTaskgroupDirective(cast<OMPTaskgroupDirective>(*S)); break; diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp index d72cd8fbfd608..bc14dac537337 100644 --- a/clang/lib/CodeGen/CGStmtOpenMP.cpp +++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp @@ -1418,6 +1418,7 @@ void CodeGenFunction::EmitOMPReductionClauseInit( case OMPD_error: case OMPD_barrier: case OMPD_taskwait: + case OMPD_taskgraph: case OMPD_taskgroup: case OMPD_flush: case OMPD_depobj: @@ -5586,6 +5587,11 @@ void CodeGenFunction::EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S) { CGM.getOpenMPRuntime().emitTaskwaitCall(*this, S.getBeginLoc(), Data); } +void CodeGenFunction::EmitOMPTaskgraphDirective( + const OMPTaskgraphDirective &S) { + CGM.getOpenMPRuntime().emitTaskgraphCall(*this, S.getBeginLoc(), S); +} + static bool isSupportedByOpenMPIRBuilder(const OMPTaskgroupDirective &T) { return T.clauses().empty(); } diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 727487b46054f..863d098c8b373 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -3879,6 +3879,7 @@ class CodeGenFunction : public CodeGenTypeCache { void EmitOMPErrorDirective(const OMPErrorDirective &S); void EmitOMPBarrierDirective(const OMPBarrierDirective &S); void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S); + void EmitOMPTaskgraphDirective(const OMPTaskgraphDirective &S); void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S); void EmitOMPFlushDirective(const OMPFlushDirective &S); void EmitOMPDepobjDirective(const OMPDepobjDirective &S); diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp index 552c92996dc2e..a38e08b6e67e4 100644 --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -1511,6 +1511,7 @@ CanThrowResult Sema::canThrow(const Stmt *S) { case Stmt::OMPScopeDirectiveClass: case Stmt::OMPTaskDirectiveClass: case Stmt::OMPTaskgroupDirectiveClass: + case Stmt::OMPTaskgraphDirectiveClass: case Stmt::OMPTaskLoopDirectiveClass: case Stmt::OMPTaskLoopSimdDirectiveClass: case Stmt::OMPTaskwaitDirectiveClass: diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index 48e06d1dc7579..2191c5cfa22e1 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -4467,6 +4467,14 @@ getUnknownRegionParams(Sema &SemaRef) { return Params; } +static SmallVector<SemaOpenMP::CapturedParamNameType> +getTaskgraphRegionParams(Sema &SemaRef) { + SmallVector<SemaOpenMP::CapturedParamNameType> Params{ + std::make_pair(StringRef(), QualType()) // __context with shared vars + }; + return Params; +} + static SmallVector<SemaOpenMP::CapturedParamNameType> getTaskloopRegionParams(Sema &SemaRef) { ASTContext &Context = SemaRef.getASTContext(); @@ -4540,6 +4548,10 @@ static void processCapturedRegions(Sema &SemaRef, OpenMPDirectiveKind DKind, // function directly. MarkAsInlined(SemaRef.getCurCapturedRegion()); break; + case OMPD_taskgraph: + SemaRef.ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, + getTaskgraphRegionParams(SemaRef), Level); + break; case OMPD_target: SemaRef.ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, getTargetRegionParams(SemaRef), Level); @@ -6496,6 +6508,12 @@ StmtResult SemaOpenMP::ActOnOpenMPExecutableDirective( "No associated statement allowed for 'omp taskwait' directive"); Res = ActOnOpenMPTaskwaitDirective(ClausesWithImplicit, StartLoc, EndLoc); break; + case OMPD_taskgraph: + assert(AStmt != nullptr && + "Associated statement required for 'omp taskgraph' directive"); + Res = ActOnOpenMPTaskgraphDirective(ClausesWithImplicit, AStmt, StartLoc, + EndLoc); + ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/159774 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
