llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-static-analyzer-1 @llvm/pr-subscribers-clang Author: Krzysztof Parzyszek (kparzysz) <details> <summary>Changes</summary> Now that OMPD_ordered has been replaced with two variants, split the OMPOrderedDirective class into two classes, one for each variant. --- Patch is 37.28 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/214730.diff 23 Files Affected: - (modified) clang/bindings/python/clang/cindex.py (+5-2) - (modified) clang/include/clang-c/Index.h (+6-2) - (modified) clang/include/clang/AST/RecursiveASTVisitor.h (+4-1) - (modified) clang/include/clang/AST/StmtOpenMP.h (+63-15) - (modified) clang/include/clang/Basic/StmtNodes.td (+2-1) - (modified) clang/include/clang/Serialization/ASTBitCodes.h (+2-1) - (modified) clang/lib/AST/StmtOpenMP.cpp (+25-20) - (modified) clang/lib/AST/StmtPrinter.cpp (+9-2) - (modified) clang/lib/AST/StmtProfile.cpp (+7-1) - (modified) clang/lib/CIR/CodeGen/CIRGenFunction.h (+4-1) - (modified) clang/lib/CIR/CodeGen/CIRGenStmt.cpp (+6-2) - (modified) clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp (+10-3) - (modified) clang/lib/CodeGen/CGStmt.cpp (+5-2) - (modified) clang/lib/CodeGen/CGStmtOpenMP.cpp (+77-71) - (modified) clang/lib/CodeGen/CodeGenFunction.h (+4-1) - (modified) clang/lib/Sema/SemaExceptionSpec.cpp (+2-1) - (modified) clang/lib/Sema/SemaOpenMP.cpp (+5-2) - (modified) clang/lib/Sema/TreeTransform.h (+14-3) - (modified) clang/lib/Serialization/ASTReaderStmt.cpp (+18-5) - (modified) clang/lib/Serialization/ASTWriterStmt.cpp (+10-2) - (modified) clang/lib/StaticAnalyzer/Core/ExprEngine.cpp (+2-1) - (modified) clang/tools/libclang/CIndex.cpp (+15-4) - (modified) clang/tools/libclang/CXCursor.cpp (+5-2) ``````````diff diff --git a/clang/bindings/python/clang/cindex.py b/clang/bindings/python/clang/cindex.py index 126c7bf44d1d1..8fb63af29bc56 100644 --- a/clang/bindings/python/clang/cindex.py +++ b/clang/bindings/python/clang/cindex.py @@ -1261,8 +1261,8 @@ def is_unexposed(self): # Windows Structured Exception Handling's leave statement. SEH_LEAVE_STMT = 247 - # OpenMP ordered directive. - OMP_ORDERED_DIRECTIVE = 248 + # OpenMP ordered-standalone directive. + OMP_ORDERED_STANDALONE_DIRECTIVE = 248 # OpenMP atomic directive. OMP_ATOMIC_DIRECTIVE = 249 @@ -1456,6 +1456,9 @@ def is_unexposed(self): # OpenMP split directive. OMP_SPLIT_DIRECTIVE = 312 + # OpenMP ordered-blockassoc directive. + OMP_ORDERED_BLOCKASSOC_DIRECTIVE = 313 + # OpenACC Compute Construct. OPEN_ACC_COMPUTE_DIRECTIVE = 320 diff --git a/clang/include/clang-c/Index.h b/clang/include/clang-c/Index.h index 8427236e0b444..1c8d097f1beab 100644 --- a/clang/include/clang-c/Index.h +++ b/clang/include/clang-c/Index.h @@ -1910,9 +1910,9 @@ enum CXCursorKind { */ CXCursor_SEHLeaveStmt = 247, - /** OpenMP ordered directive. + /** OpenMP ordered-standalone directive. */ - CXCursor_OMPOrderedDirective = 248, + CXCursor_OMPOrderedStandaloneDirective = 248, /** OpenMP atomic directive. */ @@ -2170,6 +2170,10 @@ enum CXCursorKind { */ CXCursor_OMPSplitDirective = 312, + /** OpenMP ordered-blockassoc directive. + */ + CXCursor_OMPOrderedBlockAssocDirective = 313, + /** OpenACC Compute Construct. */ CXCursor_OpenACCComputeConstruct = 320, diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index 6913e9b614315..617990b82edca 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -3319,7 +3319,10 @@ DEF_TRAVERSE_STMT(OMPDepobjDirective, DEF_TRAVERSE_STMT(OMPScanDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) -DEF_TRAVERSE_STMT(OMPOrderedDirective, +DEF_TRAVERSE_STMT(OMPOrderedStandaloneDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + +DEF_TRAVERSE_STMT(OMPOrderedBlockAssocDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) DEF_TRAVERSE_STMT(OMPAtomicDirective, diff --git a/clang/include/clang/AST/StmtOpenMP.h b/clang/include/clang/AST/StmtOpenMP.h index 2d0cfb1580aeb..cb154866e1ca2 100644 --- a/clang/include/clang/AST/StmtOpenMP.h +++ b/clang/include/clang/AST/StmtOpenMP.h @@ -554,9 +554,6 @@ class OMPExecutableDirective : public Stmt { } OpenMPDirectiveKind getDirectiveKind() const { return Kind; } - void setDirectiveKind(OpenMPDirectiveKind D) const { - const_cast<OMPExecutableDirective *>(this)->Kind = D; - } static bool classof(const Stmt *S) { return S->getStmtClass() >= firstOMPExecutableDirectiveConstant && @@ -2934,13 +2931,13 @@ class OMPDepobjDirective final : public OMPExecutableDirective { } }; -/// This represents '#pragma omp ordered' directive. +/// This represents standalone '#pragma omp ordered' directive. /// /// \code /// #pragma omp ordered /// \endcode /// -class OMPOrderedDirective : public OMPExecutableDirective { +class OMPOrderedStandaloneDirective : public OMPExecutableDirective { friend class ASTStmtReader; friend class OMPExecutableDirective; /// Build directive with the given start and end location. @@ -2948,18 +2945,71 @@ class OMPOrderedDirective : public OMPExecutableDirective { /// \param StartLoc Starting location of the directive kind. /// \param EndLoc Ending location of the directive. /// - OMPOrderedDirective(SourceLocation StartLoc, SourceLocation EndLoc) - : OMPExecutableDirective(OMPOrderedDirectiveClass, + OMPOrderedStandaloneDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(OMPOrderedStandaloneDirectiveClass, llvm::omp::OMPD_ordered_standalone, StartLoc, EndLoc) {} /// Build an empty directive. /// - explicit OMPOrderedDirective() - : OMPExecutableDirective(OMPOrderedDirectiveClass, + explicit OMPOrderedStandaloneDirective() + : OMPExecutableDirective(OMPOrderedStandaloneDirectiveClass, llvm::omp::OMPD_ordered_standalone, SourceLocation(), SourceLocation()) {} +public: + /// Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// \param Clauses List of clauses. + /// + static OMPOrderedStandaloneDirective *Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + ArrayRef<OMPClause *> Clauses); + + /// Creates an empty directive. + /// + /// \param C AST context. + /// \param NumClauses Number of clauses. + /// + static OMPOrderedStandaloneDirective * + CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell); + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPOrderedStandaloneDirectiveClass; + } +}; + +/// This represents block-associated '#pragma omp ordered' directive. +/// +/// \code +/// #pragma omp ordered +/// { body } +/// \endcode +/// +class OMPOrderedBlockAssocDirective : 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. + /// + OMPOrderedBlockAssocDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(OMPOrderedBlockAssocDirectiveClass, + llvm::omp::OMPD_ordered_blockassoc, StartLoc, + EndLoc) {} + + /// Build an empty directive. + /// + explicit OMPOrderedBlockAssocDirective() + : OMPExecutableDirective(OMPOrderedBlockAssocDirectiveClass, + llvm::omp::OMPD_ordered_blockassoc, + SourceLocation(), SourceLocation()) {} + public: /// Creates directive. /// @@ -2969,7 +3019,7 @@ class OMPOrderedDirective : public OMPExecutableDirective { /// \param Clauses List of clauses. /// \param AssociatedStmt Statement, associated with the directive. /// - static OMPOrderedDirective * + static OMPOrderedBlockAssocDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt); @@ -2977,14 +3027,12 @@ class OMPOrderedDirective : public OMPExecutableDirective { /// /// \param C AST context. /// \param NumClauses Number of clauses. - /// \param IsStandalone true, if the standalone directive is created. /// - static OMPOrderedDirective *CreateEmpty(const ASTContext &C, - unsigned NumClauses, - bool IsStandalone, EmptyShell); + static OMPOrderedBlockAssocDirective * + CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell); static bool classof(const Stmt *T) { - return T->getStmtClass() == OMPOrderedDirectiveClass; + return T->getStmtClass() == OMPOrderedBlockAssocDirectiveClass; } }; diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td index f5fa397c92ef3..6df244d7a8c90 100644 --- a/clang/include/clang/Basic/StmtNodes.td +++ b/clang/include/clang/Basic/StmtNodes.td @@ -278,7 +278,8 @@ def OMPTaskgroupDirective : StmtNode<OMPExecutableDirective>; def OMPFlushDirective : StmtNode<OMPExecutableDirective>; def OMPDepobjDirective : StmtNode<OMPExecutableDirective>; def OMPScanDirective : StmtNode<OMPExecutableDirective>; -def OMPOrderedDirective : StmtNode<OMPExecutableDirective>; +def OMPOrderedStandaloneDirective : StmtNode<OMPExecutableDirective>; +def OMPOrderedBlockAssocDirective : StmtNode<OMPExecutableDirective>; def OMPAtomicDirective : StmtNode<OMPExecutableDirective>; def OMPTargetDirective : StmtNode<OMPExecutableDirective>; def OMPTargetDataDirective : StmtNode<OMPExecutableDirective>; diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h index 7dee847e44410..fcaa6cf2a6af4 100644 --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -2004,7 +2004,8 @@ enum StmtCode { STMT_OMP_FLUSH_DIRECTIVE, STMT_OMP_DEPOBJ_DIRECTIVE, STMT_OMP_SCAN_DIRECTIVE, - STMT_OMP_ORDERED_DIRECTIVE, + STMT_OMP_ORDERED_STANDALONE_DIRECTIVE, + STMT_OMP_ORDERED_BLOCKASSOC_DIRECTIVE, STMT_OMP_ATOMIC_DIRECTIVE, STMT_OMP_TARGET_DIRECTIVE, STMT_OMP_TARGET_DATA_DIRECTIVE, diff --git a/clang/lib/AST/StmtOpenMP.cpp b/clang/lib/AST/StmtOpenMP.cpp index e4144cb544a9d..0a0cf6352808f 100644 --- a/clang/lib/AST/StmtOpenMP.cpp +++ b/clang/lib/AST/StmtOpenMP.cpp @@ -1057,28 +1057,33 @@ OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C, return createEmptyDirective<OMPScanDirective>(C, NumClauses); } -OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C, - SourceLocation StartLoc, - SourceLocation EndLoc, - ArrayRef<OMPClause *> Clauses, - Stmt *AssociatedStmt) { - auto *D = createDirective<OMPOrderedDirective>( - C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt), - /*NumChildren=*/0, StartLoc, EndLoc); - if (AssociatedStmt) - D->setDirectiveKind(OMPD_ordered_blockassoc); - return D; +OMPOrderedStandaloneDirective *OMPOrderedStandaloneDirective::Create( + const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + ArrayRef<OMPClause *> Clauses) { + return createDirective<OMPOrderedStandaloneDirective>( + C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, + EndLoc); } -OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C, - unsigned NumClauses, - bool IsStandalone, - EmptyShell) { - auto *D = - createEmptyDirective<OMPOrderedDirective>(C, NumClauses, !IsStandalone); - if (!IsStandalone) - D->setDirectiveKind(OMPD_ordered_blockassoc); - return D; +OMPOrderedStandaloneDirective * +OMPOrderedStandaloneDirective::CreateEmpty(const ASTContext &C, + unsigned NumClauses, EmptyShell) { + return createEmptyDirective<OMPOrderedStandaloneDirective>(C, NumClauses); +} + +OMPOrderedBlockAssocDirective *OMPOrderedBlockAssocDirective::Create( + const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { + return createDirective<OMPOrderedBlockAssocDirective>( + C, Clauses, cast<CapturedStmt>(AssociatedStmt), /*NumChildren=*/0, + StartLoc, EndLoc); +} + +OMPOrderedBlockAssocDirective * +OMPOrderedBlockAssocDirective::CreateEmpty(const ASTContext &C, + unsigned NumClauses, EmptyShell) { + return createEmptyDirective<OMPOrderedBlockAssocDirective>( + C, NumClauses, /*HasAssociatedStmt=*/true); } OMPAtomicDirective * diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp index 877191d456b35..eeb377c794e05 100644 --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -967,9 +967,16 @@ void StmtPrinter::VisitOMPScanDirective(OMPScanDirective *Node) { PrintOMPExecutableDirective(Node); } -void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) { +void StmtPrinter::VisitOMPOrderedStandaloneDirective( + OMPOrderedStandaloneDirective *Node) { Indent() << "#pragma omp ordered"; - PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>()); + PrintOMPExecutableDirective(Node, true); +} + +void StmtPrinter::VisitOMPOrderedBlockAssocDirective( + OMPOrderedBlockAssocDirective *Node) { + Indent() << "#pragma omp ordered"; + PrintOMPExecutableDirective(Node); } void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) { diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index ec4493d0afa41..45c962aa27553 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -1203,7 +1203,13 @@ void StmtProfiler::VisitOMPScanDirective(const OMPScanDirective *S) { VisitOMPExecutableDirective(S); } -void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) { +void StmtProfiler::VisitOMPOrderedStandaloneDirective( + const OMPOrderedStandaloneDirective *S) { + VisitOMPExecutableDirective(S); +} + +void StmtProfiler::VisitOMPOrderedBlockAssocDirective( + const OMPOrderedBlockAssocDirective *S) { VisitOMPExecutableDirective(S); } diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h index d318338187f12..c639b06eff17c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.h +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h @@ -2569,7 +2569,10 @@ class CIRGenFunction : public CIRGenTypeCache { mlir::LogicalResult emitOMPFlushDirective(const OMPFlushDirective &s); mlir::LogicalResult emitOMPDepobjDirective(const OMPDepobjDirective &s); mlir::LogicalResult emitOMPScanDirective(const OMPScanDirective &s); - mlir::LogicalResult emitOMPOrderedDirective(const OMPOrderedDirective &s); + mlir::LogicalResult + emitOMPOrderedStandaloneDirective(const OMPOrderedStandaloneDirective &s); + mlir::LogicalResult + emitOMPOrderedBlockAssocDirective(const OMPOrderedBlockAssocDirective &s); mlir::LogicalResult emitOMPAtomicDirective(const OMPAtomicDirective &s); mlir::LogicalResult emitOMPTargetDirective(const OMPTargetDirective &s); mlir::LogicalResult emitOMPTeamsDirective(const OMPTeamsDirective &s); diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp index ceda5811cd065..ae2dcbd244988 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp @@ -302,8 +302,12 @@ mlir::LogicalResult CIRGenFunction::emitStmt(const Stmt *s, return emitOMPDepobjDirective(cast<OMPDepobjDirective>(*s)); case Stmt::OMPScanDirectiveClass: return emitOMPScanDirective(cast<OMPScanDirective>(*s)); - case Stmt::OMPOrderedDirectiveClass: - return emitOMPOrderedDirective(cast<OMPOrderedDirective>(*s)); + case Stmt::OMPOrderedStandaloneDirectiveClass: + return emitOMPOrderedStandaloneDirective( + cast<OMPOrderedStandaloneDirective>(*s)); + case Stmt::OMPOrderedBlockAssocDirectiveClass: + return emitOMPOrderedBlockAssocDirective( + cast<OMPOrderedBlockAssocDirective>(*s)); case Stmt::OMPAtomicDirectiveClass: return emitOMPAtomicDirective(cast<OMPAtomicDirective>(*s)); case Stmt::OMPTargetDirectiveClass: diff --git a/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp b/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp index 17a1fb8090f5c..a42735391629f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp @@ -205,9 +205,16 @@ CIRGenFunction::emitOMPScanDirective(const OMPScanDirective &s) { getCIRGenModule().errorNYI(s.getSourceRange(), "OpenMP OMPScanDirective"); return mlir::failure(); } -mlir::LogicalResult -CIRGenFunction::emitOMPOrderedDirective(const OMPOrderedDirective &s) { - getCIRGenModule().errorNYI(s.getSourceRange(), "OpenMP OMPOrderedDirective"); +mlir::LogicalResult CIRGenFunction::emitOMPOrderedStandaloneDirective( + const OMPOrderedStandaloneDirective &s) { + getCIRGenModule().errorNYI(s.getSourceRange(), + "OpenMP OMPOrderedStandaloneDirective"); + return mlir::failure(); +} +mlir::LogicalResult CIRGenFunction::emitOMPOrderedBlockAssocDirective( + const OMPOrderedBlockAssocDirective &s) { + getCIRGenModule().errorNYI(s.getSourceRange(), + "OpenMP OMPOrderedBlockAssocDirective"); return mlir::failure(); } mlir::LogicalResult diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp index 73f6c3c4aff1d..18f1e87d3245d 100644 --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -304,8 +304,11 @@ void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs) { case Stmt::OMPScanDirectiveClass: EmitOMPScanDirective(cast<OMPScanDirective>(*S)); break; - case Stmt::OMPOrderedDirectiveClass: - EmitOMPOrderedDirective(cast<OMPOrderedDirective>(*S)); + case Stmt::OMPOrderedStandaloneDirectiveClass: + EmitOMPOrderedStandaloneDirective(cast<OMPOrderedStandaloneDirective>(*S)); + break; + case Stmt::OMPOrderedBlockAssocDirectiveClass: + EmitOMPOrderedBlockAssocDirective(cast<OMPOrderedBlockAssocDirective>(*S)); break; case Stmt::OMPAtomicDirectiveClass: EmitOMPAtomicDirective(cast<OMPAtomicDirective>(*S)); diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp index c7c13af972255..122e5db698548 100644 --- a/clang/lib/CodeGen/CGStmtOpenMP.cpp +++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp @@ -2785,7 +2785,7 @@ static void emitSimdlenSafelenClause(CodeGenFunction &CGF, } } -// Check for the presence of an `OMPOrderedDirective`, +// Check for the presence of an `OMPOrderedBlockAssocDirective`, // i.e., `ordered` in `#pragma omp ordered simd`. // // Consider the following source code: @@ -2806,7 +2806,7 @@ static void emitSimdlenSafelenClause(CodeGenFunction &CGF, // // Suppose we are in `CodeGenFunction::EmitOMPSimdInit(const OMPLoopDirective // &D)`. By examining `D.dump()` we have the following AST containing -// `OMPOrderedDirective`: +// `OMPOrderedBlockAssocDirective`: // // ``` // OMPSimdDirective 0x1c32950 @@ -2824,24 +2824,24 @@ static void emitSimdlenSafelenClause(CodeGenFunction &CGF, // | | |-UnaryOperator 0x1c31348 'int' prefix '++' // | | | `-DeclRefExpr 0x1c31328 'int' lvalue Var 0x1c31208 'k' 'int' // | | `-CompoundStmt 0x1c31e18 -// | | `-OMPOrderedDirective 0x1c31dd8 +// | | `-OMPOrderedBlockAssocDirective 0x1c31dd8 // | | |-OMPSimdClause 0x1c31380 // | | `-CapturedStmt 0x1c31cd0 // ``` // -// Note the presence of `OMPOrderedDirective` above: +// Note the presence of `OMPOrderedBlockAssocDirective` above: // It's (transitively) nested in a `CapturedStmt` representing the pragma // annotated compound statement. Thus, we need to consider this nesting and // include checking the `getCapturedStmt` in this case. -static bool hasOrderedDirective(const Stmt *S) { - if (isa<OMPOrderedDirective>(S)) +static bool hasOrderedBlockAssocDirective(const Stmt *S) { + if (isa<OMPOrderedBlockAssocDirective>(S)) return true; if (const auto *CS = dyn_cast<CapturedStmt>(S)) - return hasOrderedDirective(CS->getCapturedStmt()); + return hasOrderedBlockAssocDirective(CS->getCapturedStmt()); for (const Stmt *Child : S->children()) { - if (Child && hasOrderedDirective(Child)) + if (Child && hasOrderedBlockAssocDirective(Child)) return true; } @@ -2850,9 +2850,9 @@ static bool hasOrderedDirective(const Stmt *S) { static void applyConservativeSimdOrderedDirective(const Stmt &AssociatedStmt, LoopInfoStack &LoopStack) { - // Check for the presence of an `OMPOrderedDirective` + // Check for the presence of an `OMPOrderedBlockAssocDirective` // i.e., `ordered` in `#pragma omp ordered simd` - bool HasOrderedDirective = hasOrderedDirective(&AssociatedStmt); + bool HasOrderedDirective = hasOrderedBlockAssocDirective(&AssociatedStmt); // If present then conservatively disable loop vectorization // analogously to how `emitSimdlenSafelenClause` does. if (HasOrderedDirective) @@ -3087,9 +3087,9 @@ static bool isSimdSupportedByOpenMPIRBuilder(const OMPLoopDirective &S) { return false;... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/214730 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
