https://github.com/chichunchen updated https://github.com/llvm/llvm-project/pull/233493
>From 41e782626ef06bc71452ab02b27a97108245dfbd Mon Sep 17 00:00:00 2001 From: "Chi Chun, Chen" <[email protected]> Date: Sat, 17 Oct 2026 22:32:07 -0500 Subject: [PATCH 1/2] [flang][OpenMP] Don't treat different runtime conditions as subsets When two METADIRECTIVE candidates have the same score and one selector is a strict subset of the other, the superset wins. Flang ranks every runtime condition with the same property, so isStrictSubset saw different conditions as the same: !$omp metadirective & !$omp& when(user={condition(a)}, & !$omp& implementation={vendor(score(4): llvm)}: taskyield) & !$omp& when(user={condition(b)}, device={kind(host)}, & !$omp& implementation={vendor(score(3): llvm)}: taskwait) Both candidates score 5, and `b` was tested first, so TASKWAIT ran when both conditions were true. Neither selector is a subset of the other, so clause order should decide. This patch adds a UserCondition key to VariantMatchInfo, and isStrictSubset requires equal keys when the first selector has a condition. Flang gives each distinct runtime condition of a METADIRECTIVE its own key. It compares the conditions the same way as the existing check for repeated conditions, so condition(a) and condition((a)) still form a strict subset. Like that check, it treats different names for the same entity as different conditions. Ranking also sees conditions with function calls, which that check rejects, so the comparison now also collects the symbols in the length of a character array constructor. Conditions that fold to a constant of any kind, including all of Clang's, leave the key empty and are still compared by truth value. A constant condition and a runtime condition are now different. Fixes #233038. Assisted-by: GitHub Copilot (Claude Opus 5.5) --- flang/lib/Semantics/openmp-utils.cpp | 45 +++- .../test/Lower/OpenMP/metadirective-user.f90 | 224 ++++++++++++++++++ .../include/llvm/Frontend/OpenMP/OMPContext.h | 4 + llvm/lib/Frontend/OpenMP/OMPContext.cpp | 7 + llvm/unittests/Frontend/OpenMPContextTest.cpp | 37 +++ 5 files changed, 314 insertions(+), 3 deletions(-) diff --git a/flang/lib/Semantics/openmp-utils.cpp b/flang/lib/Semantics/openmp-utils.cpp index 0c86239136553..9a116c886f1a7 100644 --- a/flang/lib/Semantics/openmp-utils.cpp +++ b/flang/lib/Semantics/openmp-utils.cpp @@ -2473,6 +2473,12 @@ static void AppendConstructTraitsForDirective( add(llvm::omp::TraitProperty::construct_dispatch_dispatch); } +static SomeExpr NormalizeMetadirectiveCondition(const SomeExpr &expr); +namespace { +template <typename T> +bool AreSameMetadirectiveCondition(const T &left, const T &right); +} // namespace + static void AddTraitPropertiesFromSelector(llvm::omp::TraitSet set, const parser::OmpTraitSelector &selector, llvm::omp::VariantMatchInfo &vmi, SemanticsContext &semaCtx, @@ -2579,6 +2585,24 @@ std::optional<MetadirectiveCandidateSet> BuildMetadirectiveCandidateSet( return spec.DirId() == llvm::omp::Directive::OMPD_nothing ? nullptr : &spec; }; + // Identify each distinct runtime condition, so that different conditions + // are not strict subsets of each other. + llvm::SmallVector<SomeExpr, 4> runtimeConditions; + auto getConditionKey = [&](const DynamicUserCondition &condition) { + const SomeExpr *expr{GetExpr(context, *condition.expr)}; + if (!expr || + evaluate::IsActuallyConstant( + evaluate::Fold(context.foldingContext(), common::Clone(*expr)))) + return std::string{}; + SomeExpr normalized{NormalizeMetadirectiveCondition(*expr)}; + auto *it{llvm::find_if(runtimeConditions, [&](const SomeExpr &condition) { + return AreSameMetadirectiveCondition(condition, normalized); + })}; + if (it == runtimeConditions.end()) + it = &runtimeConditions.emplace_back(std::move(normalized)); + return std::to_string(it - runtimeConditions.begin() + 1); + }; + for (const parser::OmpClause &clause : clauses.v) { if (const auto *whenClause{ std::get_if<parser::OmpClause::When>(&clause.u)}) { @@ -2593,6 +2617,8 @@ std::optional<MetadirectiveCandidateSet> BuildMetadirectiveCandidateSet( llvm::omp::VariantMatchInfo rawVMI; std::optional<DynamicUserCondition> dynamicCondition{ MakeVariantMatchInfo(rawVMI, *ctxSel, context)}; + if (dynamicCondition) + rawVMI.UserCondition = getConditionKey(*dynamicCondition); if (llvm::any_of( rawVMI.ConstructTraits, [](llvm::omp::TraitProperty property) { return llvm::omp::getOpenMPContextTraitSetForProperty( @@ -2751,6 +2777,14 @@ struct ConditionSymbols : evaluate::Traverse<ConditionSymbols, bool, false> { symbols.push_back(&symbol); return true; } + // Expr equality compares the length, but Traverse doesn't visit it. + template <int KIND> + bool operator()(const evaluate::ArrayConstructor< + evaluate::Type<common::TypeCategory::Character, KIND>> &x) const { + if (const auto *len{x.LEN()}) + (*this)(*len); + return Base::operator()(x); + } std::vector<const Symbol *> &symbols; }; @@ -2805,6 +2839,12 @@ bool isRepeatableMetadirectiveCondition(const SomeExpr &expr) { } } // namespace +static SomeExpr NormalizeMetadirectiveCondition(const SomeExpr &expr) { + MetadirectiveConditionNormalizer normalizer; + evaluate::rewrite::Mutator normalize{normalizer}; + return normalize(expr); +} + bool IsRepeatableMetadirectiveCondition( const parser::ScalarExpr &condition, SemanticsContext &context) { const SomeExpr *expr{GetExpr(context, condition)}; @@ -2820,10 +2860,9 @@ bool AreSameRepeatableMetadirectiveCondition(const parser::ScalarExpr &left, !isRepeatableMetadirectiveCondition(*rightExpr)) return false; - MetadirectiveConditionNormalizer normalizer; - evaluate::rewrite::Mutator normalize{normalizer}; return AreSameMetadirectiveCondition( - normalize(*leftExpr), normalize(*rightExpr)); + NormalizeMetadirectiveCondition(*leftExpr), + NormalizeMetadirectiveCondition(*rightExpr)); } llvm::SmallVector<unsigned, 4> GetMetadirectiveElsePathCandidates( diff --git a/flang/test/Lower/OpenMP/metadirective-user.f90 b/flang/test/Lower/OpenMP/metadirective-user.f90 index cdfbddd4151a0..7198d36ac2f1e 100644 --- a/flang/test/Lower/OpenMP/metadirective-user.f90 +++ b/flang/test/Lower/OpenMP/metadirective-user.f90 @@ -544,3 +544,227 @@ subroutine test_multi_dynamic_multi_static(a, b) !$omp & default(nothing) #endif end subroutine + +! Both candidates score 5. The conditions differ, so neither selector is a +! subset of the other and `a` is tested first. +! CHECK-LABEL: func.func @_QPtest_distinct_conditions( +! CHECK-SAME: %[[ARG0:[^,]*]]: !fir.ref<!fir.logical<4>> +! CHECK-SAME: %[[ARG1:.*]]: !fir.ref<!fir.logical<4>> +! CHECK: %[[DECLA:.*]]:2 = hlfir.declare %[[ARG0]] +! CHECK: %[[DECLB:.*]]:2 = hlfir.declare %[[ARG1]] +! CHECK: %[[LOADA:.*]] = fir.load %[[DECLA]]#0 +! CHECK: %[[CONDA:.*]] = fir.convert %[[LOADA]] : (!fir.logical<4>) -> i1 +! CHECK: fir.if %[[CONDA]] { +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: %[[LOADB:.*]] = fir.load %[[DECLB]]#0 +! CHECK: %[[CONDB:.*]] = fir.convert %[[LOADB]] : (!fir.logical<4>) -> i1 +! CHECK: fir.if %[[CONDB]] { +! CHECK-NEXT: omp.taskwait +! CHECK: return +subroutine test_distinct_conditions(a, b) + logical, intent(in) :: a, b + !$omp metadirective & + !$omp & when(user={condition(a)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(b)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +! With the same condition, the first selector is a strict subset of the second. +! CHECK-LABEL: func.func @_QPtest_same_condition( +! CHECK: fir.if +! CHECK-NEXT: omp.taskwait +! CHECK-NOT: omp.taskyield +! CHECK: return +subroutine test_same_condition(a) + logical, intent(in) :: a + !$omp metadirective & + !$omp & when(user={condition(a)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(a)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +! Outer parentheses don't change the condition. +! CHECK-LABEL: func.func @_QPtest_parenthesized_condition( +! CHECK: fir.if +! CHECK-NEXT: omp.taskwait +! CHECK-NOT: omp.taskyield +! CHECK: return +subroutine test_parenthesized_condition(a) + logical, intent(in) :: a + !$omp metadirective & + !$omp & when(user={condition((a))}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(a)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +! Under match_none, both candidates score 3 and `a` is tested first. +! CHECK-LABEL: func.func @_QPtest_distinct_conditions_match_none( +! CHECK-SAME: %[[ARG0:[^,]*]]: !fir.ref<!fir.logical<4>> +! CHECK: %[[DECLA:.*]]:2 = hlfir.declare %[[ARG0]] +! CHECK: %[[LOADA:.*]] = fir.load %[[DECLA]]#0 +! CHECK: %[[CONDA:.*]] = fir.convert %[[LOADA]] : (!fir.logical<4>) -> i1 +! CHECK: %[[NOTA:.*]] = arith.xori %[[CONDA]] +! CHECK: fir.if %[[NOTA]] { +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: omp.taskwait +! CHECK: return +subroutine test_distinct_conditions_match_none(a, b) + logical, intent(in) :: a, b + !$omp metadirective & + !$omp & when(user={condition(score(2): a)}, & + !$omp & implementation={extension(match_none)}: taskyield) & + !$omp & when(user={condition(b)}, device={arch(nvptx)}, & + !$omp & implementation={extension(match_none)}: taskwait) +end subroutine + +! Constant conditions are compared by truth value, whatever their kind. +! CHECK-LABEL: func.func @_QPtest_constant_condition_kinds( +! CHECK-NOT: omp.taskyield +! CHECK: omp.taskwait +! CHECK-NOT: omp.taskyield +! CHECK: return +subroutine test_constant_condition_kinds() + !$omp metadirective & + !$omp & when(user={condition(.true._8)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(.true._4)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +! Calls to intrinsics without arguments are evaluated at runtime. +! CHECK-LABEL: func.func @_QPtest_intrinsic_call_conditions( +! CHECK: arith.cmpi sgt, %{{.*}}, %c0 +! CHECK: fir.if +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: arith.cmpi sgt, %{{.*}}, %c1 +! CHECK: fir.if +! CHECK-NEXT: omp.taskwait +! CHECK: return +subroutine test_intrinsic_call_conditions() + !$omp metadirective & + !$omp & when(user={condition(command_argument_count() > 0)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(command_argument_count() > 1)}, & + !$omp & device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +module metadirective_user_a +contains + logical function predicate() + predicate = .true. + end function + logical function invoke(p) + interface + logical function p() + end function + end interface + invoke = p() + end function +end module + +module metadirective_user_b +contains + logical function predicate() + predicate = .false. + end function +end module + +! The conditions pass different procedures with the same name, so `a` is +! tested first. +! CHECK-LABEL: func.func @_QPtest_same_name_conditions( +! CHECK: fir.address_of(@_QMmetadirective_user_aPpredicate) +! CHECK: fir.if +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: fir.address_of(@_QMmetadirective_user_bPpredicate) +! CHECK: fir.if +! CHECK-NEXT: omp.taskwait +! CHECK: return +subroutine test_same_name_conditions() + use metadirective_user_a, only: a => predicate, invoke + use metadirective_user_b, only: b => predicate + !$omp metadirective & + !$omp & when(user={condition(invoke(a))}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(invoke(b))}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) +end subroutine + +! `a` and `b` are the first dummy arguments of different procedures, but they +! are different variables, so `a` is tested first. +! CHECK-LABEL: func.func private @_QFtest_host_dummy_conditionsPinner( +! CHECK-SAME: %[[ARG0:[^,]*]]: !fir.ref<!fir.logical<4>> +! CHECK: %[[A:.*]]:2 = hlfir.declare {{.*}}"_QFtest_host_dummy_conditionsEa" +! CHECK: %[[B:.*]]:2 = hlfir.declare %[[ARG0]] {{.*}}"_QFtest_host_dummy_conditionsFinnerEb" +! CHECK: %[[LOADA:.*]] = fir.load %[[A]]#0 +! CHECK: %[[CONDA:.*]] = fir.convert %[[LOADA]] +! CHECK: fir.if %[[CONDA]] { +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: fir.load %[[B]]#0 +! CHECK: omp.taskwait +! CHECK: return +subroutine test_host_dummy_conditions(a) + logical, intent(in) :: a + call inner(a) +contains + subroutine inner(b) + logical, intent(in) :: b + !$omp metadirective & + !$omp & when(user={condition(a)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(b)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) + end subroutine +end subroutine + +! `a .and. b` is not the same condition as `a`, so it is tested first. +! CHECK-LABEL: func.func private @_QFtest_host_dummy_and_conditionPinner( +! CHECK: fir.logical_and +! CHECK: fir.if +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: omp.taskwait +! CHECK: return +subroutine test_host_dummy_and_condition(a) + logical, intent(in) :: a + call inner(a) +contains + subroutine inner(b) + logical, intent(in) :: b + !$omp metadirective & + !$omp & when(user={condition(a .and. b)}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(a)}, device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) + end subroutine +end subroutine + +! The array constructors have lengths from different dummy arguments. +! CHECK-LABEL: func.func private @_QFtest_host_dummy_lengthsPinner( +! CHECK: fir.if +! CHECK-NEXT: omp.taskyield +! CHECK-NEXT: } else { +! CHECK: omp.taskwait +! CHECK: return +subroutine test_host_dummy_lengths(n) + integer, intent(in) :: n + call inner(n) +contains + subroutine inner(m) + integer, intent(in) :: m + !$omp metadirective & + !$omp & when(user={condition(maxval([character(len=n)::]) == '')}, & + !$omp & implementation={vendor(score(4): llvm)}: taskyield) & + !$omp & when(user={condition(maxval([character(len=m)::]) == '')}, & + !$omp & device={kind(host)}, & + !$omp & implementation={vendor(score(3): llvm)}: taskwait) + end subroutine +end subroutine diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPContext.h b/llvm/include/llvm/Frontend/OpenMP/OMPContext.h index 7849d32665994..c8c69823d59ed 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMPContext.h +++ b/llvm/include/llvm/Frontend/OpenMP/OMPContext.h @@ -22,6 +22,8 @@ #include "llvm/Frontend/OpenMP/OMPConstants.h" #include "llvm/Support/Compiler.h" +#include <string> + namespace llvm { class Triple; namespace omp { @@ -156,6 +158,8 @@ struct VariantMatchInfo { SmallVector<StringRef, 8> ISATraits; SmallVector<TraitProperty, 8> ConstructTraits; SmallDenseMap<TraitProperty, APInt> ScoreMap; + /// Identifies a runtime user condition; empty for a constant condition. + std::string UserCondition; }; /// The context for a source location is made up of active property traits, diff --git a/llvm/lib/Frontend/OpenMP/OMPContext.cpp b/llvm/lib/Frontend/OpenMP/OMPContext.cpp index f2cdd9bbaf5e4..dca1b6c63af39 100644 --- a/llvm/lib/Frontend/OpenMP/OMPContext.cpp +++ b/llvm/lib/Frontend/OpenMP/OMPContext.cpp @@ -172,6 +172,13 @@ static bool isStrictSubset(const VariantMatchInfo &VMI0, for (unsigned Bit : VMI0.RequiredTraits.set_bits()) if (!VMI1.RequiredTraits.test(Bit)) return false; + // Different runtime conditions share a trait, so compare them as well. + for (TraitProperty Property : + {TraitProperty::user_condition_true, TraitProperty::user_condition_false, + TraitProperty::user_condition_unknown}) + if (VMI0.RequiredTraits.test(unsigned(Property)) && + VMI0.UserCondition != VMI1.UserCondition) + return false; if (!isSubset<TraitProperty>(VMI0.ConstructTraits, VMI1.ConstructTraits)) return false; return true; diff --git a/llvm/unittests/Frontend/OpenMPContextTest.cpp b/llvm/unittests/Frontend/OpenMPContextTest.cpp index f9683ae56e933..cdf39813fe0f1 100644 --- a/llvm/unittests/Frontend/OpenMPContextTest.cpp +++ b/llvm/unittests/Frontend/OpenMPContextTest.cpp @@ -317,4 +317,41 @@ TEST_F(OpenMPContextTest, ScoringSimple) { // TODO: Add scoring tests (via getBestVariantMatchForContext). } +TEST_F(OpenMPContextTest, UserConditionInStrictSubset) { + OMPContext Context(false, Triple("x86_64-unknown-linux"), Triple(), -1); + APInt Three(64, 3), Four(64, 4), Five(64, 5); + VariantMatchInfo A, B; + A.addTrait(TraitProperty::user_condition_true, ""); + A.addTrait(TraitProperty::implementation_vendor_llvm, "", &Four); + B.addTrait(TraitProperty::user_condition_true, ""); + B.addTrait(TraitProperty::implementation_vendor_llvm, "", &Three); + B.addTrait(TraitProperty::device_kind_host, ""); + auto Best = [&](const VariantMatchInfo &First, + const VariantMatchInfo &Second) { + return getBestVariantMatchForContext( + SmallVector<VariantMatchInfo, 2>{First, Second}, Context); + }; + + // Both score 5. Constant conditions are compared by their trait alone. + EXPECT_EQ(Best(A, B), 1); + EXPECT_EQ(Best(B, A), 0); + + // Different runtime conditions keep clause order. + A.UserCondition = "a"; + B.UserCondition = "b"; + EXPECT_EQ(Best(A, B), 0); + EXPECT_EQ(Best(B, A), 0); + + // The same runtime condition still makes A a strict subset of B. + B.UserCondition = "a"; + EXPECT_EQ(Best(A, B), 1); + EXPECT_EQ(Best(B, A), 0); + + // A higher score wins regardless of the conditions. + B.UserCondition = "b"; + A.ScoreMap[TraitProperty::implementation_vendor_llvm] = Five; + EXPECT_EQ(Best(A, B), 0); + EXPECT_EQ(Best(B, A), 1); +} + } // namespace >From c11d452ec8f021b8ba9dfbc4a253a1770e8918c9 Mon Sep 17 00:00:00 2001 From: "Chi Chun, Chen" <[email protected]> Date: Mon, 19 Oct 2026 23:49:38 -0500 Subject: [PATCH 2/2] Compare the condition of an unguarded match_any candidate A match_any WHEN clause with a runtime condition also gets a candidate without the condition, since its other traits can still match. That candidate has no condition trait, so isStrictSubset skipped the key check, and it became a subset of a WHEN clause with a different condition. The key is now compared whenever it is set. --- .../test/Lower/OpenMP/metadirective-user.f90 | 35 +++++++++++++++++++ llvm/lib/Frontend/OpenMP/OMPContext.cpp | 3 ++ llvm/unittests/Frontend/OpenMPContextTest.cpp | 14 ++++++++ 3 files changed, 52 insertions(+) diff --git a/flang/test/Lower/OpenMP/metadirective-user.f90 b/flang/test/Lower/OpenMP/metadirective-user.f90 index 7198d36ac2f1e..4dd26e35e8385 100644 --- a/flang/test/Lower/OpenMP/metadirective-user.f90 +++ b/flang/test/Lower/OpenMP/metadirective-user.f90 @@ -622,6 +622,41 @@ subroutine test_distinct_conditions_match_none(a, b) !$omp & implementation={extension(match_none)}: taskwait) end subroutine +! Under match_any, the first WHEN also matches through `vendor(llvm)` when `a` is +! false. Both score 3 and the conditions differ, so TASKYIELD is always selected. +! CHECK-LABEL: func.func @_QPtest_distinct_conditions_match_any( +! CHECK-NOT: omp.taskwait +! CHECK: omp.taskyield +! CHECK-NOT: omp.taskwait +! CHECK: return +subroutine test_distinct_conditions_match_any(a, b) + logical, intent(in) :: a, b + !$omp metadirective & + !$omp & when(user={condition(a)}, & + !$omp & implementation={vendor(score(2): llvm), extension(match_any)}: & + !$omp & taskyield) & + !$omp & when(user={condition(b)}, device={kind(host)}, & + !$omp & implementation={vendor(score(1): llvm), extension(match_any)}: & + !$omp & taskwait) +end subroutine + +! A constant condition is different from a runtime condition. +! CHECK-LABEL: func.func @_QPtest_constant_and_runtime_conditions_match_any( +! CHECK-NOT: omp.taskwait +! CHECK: omp.taskyield +! CHECK-NOT: omp.taskwait +! CHECK: return +subroutine test_constant_and_runtime_conditions_match_any(b) + logical, intent(in) :: b + !$omp metadirective & + !$omp & when(user={condition(.true.)}, & + !$omp & implementation={vendor(score(2): llvm), extension(match_any)}: & + !$omp & taskyield) & + !$omp & when(user={condition(b)}, device={kind(host)}, & + !$omp & implementation={vendor(score(1): llvm), extension(match_any)}: & + !$omp & taskwait) +end subroutine + ! Constant conditions are compared by truth value, whatever their kind. ! CHECK-LABEL: func.func @_QPtest_constant_condition_kinds( ! CHECK-NOT: omp.taskyield diff --git a/llvm/lib/Frontend/OpenMP/OMPContext.cpp b/llvm/lib/Frontend/OpenMP/OMPContext.cpp index dca1b6c63af39..dffb7b2baece7 100644 --- a/llvm/lib/Frontend/OpenMP/OMPContext.cpp +++ b/llvm/lib/Frontend/OpenMP/OMPContext.cpp @@ -173,6 +173,9 @@ static bool isStrictSubset(const VariantMatchInfo &VMI0, if (!VMI1.RequiredTraits.test(Bit)) return false; // Different runtime conditions share a trait, so compare them as well. + // A runtime condition can be left out of the traits but keep its key. + if (!VMI0.UserCondition.empty() && VMI0.UserCondition != VMI1.UserCondition) + return false; for (TraitProperty Property : {TraitProperty::user_condition_true, TraitProperty::user_condition_false, TraitProperty::user_condition_unknown}) diff --git a/llvm/unittests/Frontend/OpenMPContextTest.cpp b/llvm/unittests/Frontend/OpenMPContextTest.cpp index cdf39813fe0f1..2450bcc1f63d0 100644 --- a/llvm/unittests/Frontend/OpenMPContextTest.cpp +++ b/llvm/unittests/Frontend/OpenMPContextTest.cpp @@ -352,6 +352,20 @@ TEST_F(OpenMPContextTest, UserConditionInStrictSubset) { A.ScoreMap[TraitProperty::implementation_vendor_llvm] = Five; EXPECT_EQ(Best(A, B), 0); EXPECT_EQ(Best(B, A), 1); + + // A runtime condition left out of the traits is still compared by its key. + VariantMatchInfo C; + C.addTrait(TraitProperty::implementation_vendor_llvm, "", &Four); + C.UserCondition = "a"; + EXPECT_EQ(Best(C, B), 0); + EXPECT_EQ(Best(B, C), 0); + C.UserCondition = "b"; + EXPECT_EQ(Best(C, B), 1); + + // A constant condition is different from a runtime condition. + C.UserCondition = ""; + C.addTrait(TraitProperty::user_condition_true, ""); + EXPECT_EQ(Best(C, B), 0); } } // namespace _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
