https://github.com/amitamd7 updated https://github.com/llvm/llvm-project/pull/150580
>From a7a8256e75aa6670f417540fc61998469b032596 Mon Sep 17 00:00:00 2001 From: amtiwari <[email protected]> Date: Fri, 25 Jul 2025 02:45:34 -0400 Subject: [PATCH 1/2] support_for_target_directive_clang_unittests --- clang/include/clang/ASTMatchers/ASTMatchers.h | 27 +++++ clang/lib/ASTMatchers/ASTMatchersInternal.cpp | 4 + clang/lib/ASTMatchers/Dynamic/Registry.cpp | 2 + .../ASTMatchers/ASTMatchersNarrowingTest.cpp | 99 +++++++++++++++++++ .../ASTMatchers/ASTMatchersNodeTest.cpp | 67 +++++++++++++ 5 files changed, 199 insertions(+) diff --git a/clang/include/clang/ASTMatchers/ASTMatchers.h b/clang/include/clang/ASTMatchers/ASTMatchers.h index f1d88a9523838..0ddf29095c548 100644 --- a/clang/include/clang/ASTMatchers/ASTMatchers.h +++ b/clang/include/clang/ASTMatchers/ASTMatchers.h @@ -8723,6 +8723,21 @@ AST_MATCHER_P(OMPExecutableDirective, hasAnyClause, Builder) != Clauses.end(); } +/// Matches any ``#pragma omp target update`` executable directive. +/// +/// Given +/// +/// \code +/// #pragma omp target update from(a) +/// #pragma omp target update to(b) +/// \endcode +/// +/// ``ompTargetUpdateDirective()`` matches both ``omp target update from(a)`` +/// and ``omp target update to(b)``. +extern const internal::VariadicDynCastAllOfMatcher<Stmt, + OMPTargetUpdateDirective> + ompTargetUpdateDirective; + /// Matches OpenMP ``default`` clause. /// /// Given @@ -8836,6 +8851,18 @@ AST_MATCHER_P(OMPExecutableDirective, isAllowedToContainClauseKind, Finder->getASTContext().getLangOpts().OpenMP); } +/// Matches OpenMP ``from`` clause. +/// +/// Given +/// +/// \code +/// #pragma omp target update from(a) +/// \endcode +/// +/// ``ompFromClause()`` matches ``from(a)``. +extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPFromClause> + ompFromClause; + //----------------------------------------------------------------------------// // End OpenMP handling. //----------------------------------------------------------------------------// diff --git a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp index 653b3810cb68b..1b01be069d9aa 100644 --- a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp +++ b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp @@ -1124,8 +1124,12 @@ AST_TYPELOC_TRAVERSE_MATCHER_DEF( const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective> ompExecutableDirective; +const internal::VariadicDynCastAllOfMatcher<Stmt, OMPTargetUpdateDirective> + ompTargetUpdateDirective; const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause> ompDefaultClause; +const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPFromClause> + ompFromClause; const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl> cxxDeductionGuideDecl; diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp index 48a7b91969aef..a268e97f7aa18 100644 --- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp @@ -528,7 +528,9 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(ofClass); REGISTER_MATCHER(ofKind); REGISTER_MATCHER(ompDefaultClause); + REGISTER_MATCHER(ompFromClause); REGISTER_MATCHER(ompExecutableDirective); + REGISTER_MATCHER(ompTargetUpdateDirective); REGISTER_MATCHER(on); REGISTER_MATCHER(onImplicitObjectArgument); REGISTER_MATCHER(opaqueValueExpr); diff --git a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp index 8a957864cdd12..c30398605af5d 100644 --- a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp +++ b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp @@ -4734,6 +4734,105 @@ void x() { EXPECT_TRUE(matchesWithOpenMP(Source8, Matcher)); } +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsStandaloneDirective) { + auto Matcher = ompTargetUpdateDirective(isStandaloneDirective()); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); +} + +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasStructuredBlock) { + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(notMatchesWithOpenMP( + Source0, ompTargetUpdateDirective(hasStructuredBlock(nullStmt())))); +} + +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasClause) { + auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompFromClause())); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); + + auto astUnit = tooling::buildASTFromCodeWithArgs(Source0, {"-fopenmp"}); + ASSERT_TRUE(astUnit); + + auto Results = match(ompTargetUpdateDirective().bind("directive"), + astUnit->getASTContext()); + ASSERT_FALSE(Results.empty()); + + const auto *Directive = + Results[0].getNodeAs<OMPTargetUpdateDirective>("directive"); + ASSERT_TRUE(Directive); + + OMPFromClause *FromClause = nullptr; + for (auto *Clause : Directive->clauses()) { + if ((FromClause = dyn_cast<OMPFromClause>(Clause))) { + break; + } + } + ASSERT_TRUE(FromClause); + + for (const auto *VarExpr : FromClause->varlist()) { + const auto *ArraySection = dyn_cast<ArraySectionExpr>(VarExpr); + if (!ArraySection) + continue; + // base (arr) + const Expr *Base = ArraySection->getBase(); + ASSERT_TRUE(Base); + + // lower bound (0) + const Expr *LowerBound = ArraySection->getLowerBound(); + ASSERT_TRUE(LowerBound); + + // length (8) + const Expr *Length = ArraySection->getLength(); + ASSERT_TRUE(Length); + + // stride (2) + const Expr *Stride = ArraySection->getStride(); + ASSERT_TRUE(Stride); + } +} + +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsAllowedToContainClauseKind) { + auto Matcher = ompTargetUpdateDirective( + isAllowedToContainClauseKind(llvm::omp::OMPC_from)); + + StringRef Source0 = R"( + void x() { + ; + } + )"; + EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher)); + + StringRef Source1 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher)); +} + TEST_P(ASTMatchersTest, HasAnyBase_DirectBase) { if (!GetParam().isCXX()) { return; diff --git a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp index d7df9cae01f33..f2155a92a88e8 100644 --- a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp +++ b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp @@ -2742,6 +2742,73 @@ void x() { EXPECT_TRUE(notMatchesWithOpenMP(Source2, Matcher)); } +TEST(ASTMatchersTestOpenMP, OMPTargetUpdateDirective) { + auto Matcher = stmt(ompTargetUpdateDirective()); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); +} + +TEST(ASTMatchersTestOpenMP, OMPFromClause) { + auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompFromClause())); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update from(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); + + auto astUnit = tooling::buildASTFromCodeWithArgs(Source0, {"-fopenmp"}); + ASSERT_TRUE(astUnit); + + auto Results = match(ompTargetUpdateDirective().bind("directive"), + astUnit->getASTContext()); + ASSERT_FALSE(Results.empty()); + + const auto *Directive = + Results[0].getNodeAs<OMPTargetUpdateDirective>("directive"); + ASSERT_TRUE(Directive); + + OMPFromClause *FromClause = nullptr; + for (auto *Clause : Directive->clauses()) { + if ((FromClause = dyn_cast<OMPFromClause>(Clause))) { + break; + } + } + ASSERT_TRUE(FromClause); + + for (const auto *VarExpr : FromClause->varlist()) { + const auto *ArraySection = dyn_cast<ArraySectionExpr>(VarExpr); + if (!ArraySection) + continue; + + // base (arr) + const Expr *Base = ArraySection->getBase(); + ASSERT_TRUE(Base); + + // lower bound (0) + const Expr *LowerBound = ArraySection->getLowerBound(); + ASSERT_TRUE(LowerBound); + + // length (8) + const Expr *Length = ArraySection->getLength(); + ASSERT_TRUE(Length); + + // stride (2) + const Expr *Stride = ArraySection->getStride(); + ASSERT_TRUE(Stride); + } +} + TEST(ASTMatchersTestOpenMP, OMPDefaultClause) { auto Matcher = ompExecutableDirective(hasAnyClause(ompDefaultClause())); >From cf555364d263bad4c619c9e9ca1f93a6a32ac108 Mon Sep 17 00:00:00 2001 From: amtiwari <[email protected]> Date: Fri, 5 Dec 2025 01:52:16 -0500 Subject: [PATCH 2/2] update_to clause support --- clang/include/clang/ASTMatchers/ASTMatchers.h | 12 ++ clang/lib/ASTMatchers/ASTMatchersInternal.cpp | 1 + clang/lib/ASTMatchers/Dynamic/Registry.cpp | 1 + .../ASTMatchers/ASTMatchersNarrowingTest.cpp | 106 +++++++++++++++++- .../ASTMatchers/ASTMatchersNodeTest.cpp | 69 +++++++++++- 5 files changed, 184 insertions(+), 5 deletions(-) diff --git a/clang/include/clang/ASTMatchers/ASTMatchers.h b/clang/include/clang/ASTMatchers/ASTMatchers.h index 0ddf29095c548..f007ef3bdf88d 100644 --- a/clang/include/clang/ASTMatchers/ASTMatchers.h +++ b/clang/include/clang/ASTMatchers/ASTMatchers.h @@ -8863,6 +8863,18 @@ AST_MATCHER_P(OMPExecutableDirective, isAllowedToContainClauseKind, extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPFromClause> ompFromClause; +/// Matches OpenMP ``to`` clause. +/// +/// Given +/// +/// \code +/// #pragma omp target update to(a) +/// \endcode +/// +/// ``ompToClause()`` matches ``to(a)``. +extern const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPToClause> + ompToClause; + //----------------------------------------------------------------------------// // End OpenMP handling. //----------------------------------------------------------------------------// diff --git a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp index 1b01be069d9aa..5efa7f162789c 100644 --- a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp +++ b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp @@ -1130,6 +1130,7 @@ const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPDefaultClause> ompDefaultClause; const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPFromClause> ompFromClause; +const internal::VariadicDynCastAllOfMatcher<OMPClause, OMPToClause> ompToClause; const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl> cxxDeductionGuideDecl; diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp index a268e97f7aa18..447c70dc6f9af 100644 --- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp @@ -529,6 +529,7 @@ RegistryMaps::RegistryMaps() { REGISTER_MATCHER(ofKind); REGISTER_MATCHER(ompDefaultClause); REGISTER_MATCHER(ompFromClause); + REGISTER_MATCHER(ompToClause); REGISTER_MATCHER(ompExecutableDirective); REGISTER_MATCHER(ompTargetUpdateDirective); REGISTER_MATCHER(on); diff --git a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp index c30398605af5d..63639cc890ec9 100644 --- a/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp +++ b/clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp @@ -4734,7 +4734,7 @@ void x() { EXPECT_TRUE(matchesWithOpenMP(Source8, Matcher)); } -TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsStandaloneDirective) { +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_From_IsStandaloneDirective) { auto Matcher = ompTargetUpdateDirective(isStandaloneDirective()); StringRef Source0 = R"( @@ -4747,7 +4747,20 @@ TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsStandaloneDirective) { EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); } -TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasStructuredBlock) { +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_To_IsStandaloneDirective) { + auto Matcher = ompTargetUpdateDirective(isStandaloneDirective()); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); +} + +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_From_HasStructuredBlock) { StringRef Source0 = R"( void foo() { int arr[8]; @@ -4759,7 +4772,19 @@ TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasStructuredBlock) { Source0, ompTargetUpdateDirective(hasStructuredBlock(nullStmt())))); } -TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasClause) { +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_To_HasStructuredBlock) { + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(notMatchesWithOpenMP( + Source0, ompTargetUpdateDirective(hasStructuredBlock(nullStmt())))); +} + +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_From_HasClause) { auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompFromClause())); StringRef Source0 = R"( @@ -4812,7 +4837,58 @@ TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_HasClause) { } } -TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsAllowedToContainClauseKind) { +TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_To_HasClause) { + auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompToClause())); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); + + auto astUnit = tooling::buildASTFromCodeWithArgs(Source0, {"-fopenmp"}); + ASSERT_TRUE(astUnit); + + auto Results = match(ompTargetUpdateDirective().bind("directive"), + astUnit->getASTContext()); + ASSERT_FALSE(Results.empty()); + + const auto *Directive = + Results[0].getNodeAs<OMPTargetUpdateDirective>("directive"); + ASSERT_TRUE(Directive); + + OMPToClause *ToClause = nullptr; + for (auto *Clause : Directive->clauses()) { + if ((ToClause = dyn_cast<OMPToClause>(Clause))) { + break; + } + } + ASSERT_TRUE(ToClause); + + for (const auto *VarExpr : ToClause->varlist()) { + const auto *ArraySection = dyn_cast<ArraySectionExpr>(VarExpr); + if (!ArraySection) + continue; + + const Expr *Base = ArraySection->getBase(); + ASSERT_TRUE(Base); + + const Expr *LowerBound = ArraySection->getLowerBound(); + ASSERT_TRUE(LowerBound); + + const Expr *Length = ArraySection->getLength(); + ASSERT_TRUE(Length); + + const Expr *Stride = ArraySection->getStride(); + ASSERT_TRUE(Stride); + } +} + +TEST_P(ASTMatchersTest, + OMPTargetUpdateDirective_IsAllowedToContainClauseKind_From) { auto Matcher = ompTargetUpdateDirective( isAllowedToContainClauseKind(llvm::omp::OMPC_from)); @@ -4833,6 +4909,28 @@ TEST_P(ASTMatchersTest, OMPTargetUpdateDirective_IsAllowedToContainClauseKind) { EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher)); } +TEST_P(ASTMatchersTest, + OMPTargetUpdateDirective_IsAllowedToContainClauseKind_To) { + auto Matcher = ompTargetUpdateDirective( + isAllowedToContainClauseKind(llvm::omp::OMPC_to)); + + StringRef Source0 = R"( + void x() { + ; + } + )"; + EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher)); + + StringRef Source1 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source1, Matcher)); +} + TEST_P(ASTMatchersTest, HasAnyBase_DirectBase) { if (!GetParam().isCXX()) { return; diff --git a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp index f2155a92a88e8..edc84704b5ed2 100644 --- a/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp +++ b/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp @@ -2742,7 +2742,7 @@ void x() { EXPECT_TRUE(notMatchesWithOpenMP(Source2, Matcher)); } -TEST(ASTMatchersTestOpenMP, OMPTargetUpdateDirective) { +TEST(ASTMatchersTestOpenMP, OMPTargetUpdateDirective_From) { auto Matcher = stmt(ompTargetUpdateDirective()); StringRef Source0 = R"( @@ -2755,6 +2755,19 @@ TEST(ASTMatchersTestOpenMP, OMPTargetUpdateDirective) { EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); } +TEST(ASTMatchersTestOpenMP, OMPTargetUpdateDirective_To) { + auto Matcher = stmt(ompTargetUpdateDirective()); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); +} + TEST(ASTMatchersTestOpenMP, OMPFromClause) { auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompFromClause())); @@ -2809,6 +2822,60 @@ TEST(ASTMatchersTestOpenMP, OMPFromClause) { } } +TEST(ASTMatchersTestOpenMP, OMPToClause) { + auto Matcher = ompTargetUpdateDirective(hasAnyClause(ompToClause())); + + StringRef Source0 = R"( + void foo() { + int arr[8]; + #pragma omp target update to(arr[0:8:2]) + ; + } + )"; + EXPECT_TRUE(matchesWithOpenMP(Source0, Matcher)); + + auto astUnit = tooling::buildASTFromCodeWithArgs(Source0, {"-fopenmp"}); + ASSERT_TRUE(astUnit); + + auto Results = match(ompTargetUpdateDirective().bind("directive"), + astUnit->getASTContext()); + ASSERT_FALSE(Results.empty()); + + const auto *Directive = + Results[0].getNodeAs<OMPTargetUpdateDirective>("directive"); + ASSERT_TRUE(Directive); + + OMPToClause *ToClause = nullptr; + for (auto *Clause : Directive->clauses()) { + if ((ToClause = dyn_cast<OMPToClause>(Clause))) { + break; + } + } + ASSERT_TRUE(ToClause); + + for (const auto *VarExpr : ToClause->varlist()) { + const auto *ArraySection = dyn_cast<ArraySectionExpr>(VarExpr); + if (!ArraySection) + continue; + + // base (arr) + const Expr *Base = ArraySection->getBase(); + ASSERT_TRUE(Base); + + // lower bound (0) + const Expr *LowerBound = ArraySection->getLowerBound(); + ASSERT_TRUE(LowerBound); + + // length (8) + const Expr *Length = ArraySection->getLength(); + ASSERT_TRUE(Length); + + // stride (2) + const Expr *Stride = ArraySection->getStride(); + ASSERT_TRUE(Stride); + } +} + TEST(ASTMatchersTestOpenMP, OMPDefaultClause) { auto Matcher = ompExecutableDirective(hasAnyClause(ompDefaultClause())); _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
