[llvm-branch-commits] [clang] [clang][OpenMP] Split OMPOrderedDirective into two classes (PR #214730)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Aug 7 06:36:26 PDT 2026
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
More information about the llvm-branch-commits
mailing list