[clang] Eliminate relational function pointer comparisons in all C++ modes

[mizvekov]

Summary

Word on the grapevine is that the committee has unanimous
agreement on eliminating relational function pointer comparisons.
There isn't any wording on it or anything, yet, but we must jump the gun here
and just do away with it pronto.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

• Update more tests.
• Slightly improved error recovery: deduce type for non-three-way relational comparisons.

[mizvekov]

• Add one more test case.
• Formating

[mizvekov]

clang/test/Parser/cxx-template-argument.cpp

28

So here we are recovering from the parser error into this type check error.
Maybe there is something that could be improved as a follow up task so we don't get a double error.

[• Quuxplusone]

There isn't any wording on it or anything, yet, but we must jump the gun here and just do away with it pronto.

I think "must" is the wrong word here. "Might as well"? Anyway, I agree with this general idea, FWLIW.

clang/lib/Sema/SemaExpr.cpp

11815

Peanut gallery says: Is QualType() the right "placeholder" to return here? IIUC, this is the situation where we've diagnosed an ill-formed expression and are just trying to do error-recovery: if the expression looks like x < y then we assume the programmer wants it to return bool, and if the expression looks like x <=> y then we assume the programmer wants it to return... QualType()? Is that the same thing we'd do for e.g. x + y or undeclaredfunction(x)? (If so, good, I think.)

clang/test/Parser/cxx-template-argument.cpp

28

Since this is a parsing test, not a semantics test, I think it should avoid doing anything sketchy semantic-wise. It should just be rewritten as something like

struct RHS {
    friend void operator==(void(*)(), RHS) {}
    friend void operator>=(void(*)(), RHS) {}
};
(void)(&t<int>==RHS());
(void)(&t<int>>=RHS());
(void)(&t<S<int>>==RHS());
(void)(&t<S<int>>>=RHS());

clang/test/SemaCXX/compare-function-pointer.cpp

13

I believe you should also test these same cases for a OP c where c is a different function pointer type, e.g. int (*c)();

clang/test/SemaTemplate/resolve-single-template-id.cpp

77–79

Cast (void)(x < y) here to suppress one of these irrelevant warnings.
The combination of warning "expr always evaluates to false" and erroring "expr is ill-formed" is also silly, but I suppose we can't do much about it.

[mizvekov]

clang/lib/Sema/SemaExpr.cpp

11815

So right now, this is the same we are doing for three-way comparison between builtin types we do not support / recognize. Check just below in this same function. Just look for the call to getComparisonCategoryForBuiltinCmp.

I agree completely with you and I was going to raise the same point, but I would prefer we changed both places at once instead of fixing it just here, so I think this should be a follow up task: Find something more appropriate to return here.

clang/test/Parser/cxx-template-argument.cpp

28

I like that idea.

clang/test/SemaCXX/compare-function-pointer.cpp

13

Sounds good.

clang/test/SemaTemplate/resolve-single-template-id.cpp

77–79

I tried avoid changing the original test because I am not sure what the original intention was, but I agree in principle the two errors already give enough indication that the compiler is figuring out what is happening here correctly.

[mizvekov]

Implement 2/3 of Arthur's suggestions.

[mizvekov]

clang/test/SemaTemplate/resolve-single-template-id.cpp

77–79

Taking another look at this test, it is doing too much weird stuff like this all over the place, and I am a bit hesitant to make such a change because the test scope is really not clear here...

I would be more open to suppressing this warning by passing a command line flag, but even then I would wait for a second opinion.

Some crazy talk on my part here, but I wonder a bit if this is somehow bothering us because there are so many diagnostics thrown in such small amount of code. Perhaps a bit like how we might feel pointing someone out for too many errors is not very social?
Suppose the user writes this 10 character statement and he gets one error and two warnings, that might offend him a little bit, maybe?

[rsmith]

I would prefer to split this into two changes:

1. Stop providing a builtin overload candidate R operator<=>(P, P) where P is a function pointer type, to be consistent with the behavior of the built-in <=> operator.
2. Stop providing </<=/>/>= support for function pointer types.

I think (1) is a (relatively) safe change that we can make immediately with very little roll-out concern. <=> is new, and the built-in candidate would never work anyway, so this is unlikely to cause problems for any real code, and has had clear and unanimous support in C++ committee discussions. So let's do that.

I think (2) is a lot riskier for existing code, and I think there's at least some chance that the C++ committee will end up effectively asking for change (1) but not change (2). It also looks like this part of the change will require a matching change in the standard library, because std::less on function pointer types would presumably still be required to work. So I think a safer approach here would be to add an enabled-by-default warning for relational comparisons of function pointers now, and return to this later to make the comparisons ill-formed if it still looks like the C++ committee is moving in that direction.

Does that sound reasonable?

clang/lib/Sema/SemaExpr.cpp

11807

11815

A null QualType is in this case treated as an indication that the comparison is invalid, recovery failed, and the callee has already produced a diagnostic. (It's a bit sad that we don't generally use a separate TypeResult for this kind of thing in order to distinguish between the "no type" answer and the "invalid and I've produced a diagnostic" answer, but if we wanted to change that I think we should aim to do it holistically across all of Clang.)

clang/lib/Sema/SemaOverload.cpp

9226–9228

An /*IsOrdered*/ comment here and below (or use of an enum) would aid readability.

[mizvekov]

In D104680#2839309, @rsmith wrote:

I would prefer to split this into two changes:
...
Does that sound reasonable?

Yeah that is fine, totally understand ;)

clang/lib/Sema/SemaExpr.cpp

11815

Hmm. My thinking here is that it would be totally appropriate to error recovery with a 'strong_ordering' type, since that can decay into all the other orderings, making it kind of a safe bet that it would not cause further problems.

The idea of a separate type for error recovery is intriguing. But I wonder if it would be appropriate in some cases, but not all of them.

• The cases where all the options are equally bad and we have no good guesses would fit the bill, but this is not the case here.
• When we have a good safe bet, we can in principle just use that type. But maybe it would make sense to add a bit to it that means something like "but don't take this too seriously", which could be used to selectively suppress some diagnostics downstream.

[mizvekov]

First part of the split implemented at: https://reviews.llvm.org/D104892
I will reuse this DR for the second part.

[mizvekov]

• Rebase after split.
• Add tests which I had forgotten, covering the builtin candidates for the relational operators other than spaceship.

[mizvekov]

• Fix missing period as pointed by rsmith.

[joerg]

Is there any reason for breaking C++03 code here? I don't see the advantage to that at all.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_typecheck_compare_complete_incomplete_pointers : Extension<
   "pointer comparisons before C11 "
   "need to be between two complete or two incomplete types; "
   "%0 is %select{|in}2complete and "
   "%1 is %select{|in}3complete">,
   InGroup<C11>;
 def ext_typecheck_ordered_comparison_of_function_pointers : ExtWarn<
   "ordered comparison of function pointers (%0 and %1)">,
   InGroup<DiagGroup<"ordered-compare-function-pointers">>;
+def err_typecheck_ordered_comparison_of_function_pointers : Error<
+  "ordered comparison of function pointers (%0 and %1)">;
 def ext_typecheck_comparison_of_fptr_to_void : Extension<
   "equality comparison between function pointer and void pointer (%0 and %1)">;
 def err_typecheck_comparison_of_fptr_to_void : Error<
   "equality comparison between function pointer and void pointer (%0 and %1)">;
 def ext_typecheck_comparison_of_pointer_integer : ExtWarn<
   "comparison between pointer and integer (%0 and %1)">,
   InGroup<DiagGroup<"pointer-integer-compare">>;
 def err_typecheck_comparison_of_pointer_integer : Error<

 def err_defaulted_comparison_cannot_deduce_undeduced_auto : Error<
   "return type of defaulted 'operator<=>' cannot be deduced because "
   "three-way comparison for %select{|member|base class}0 %1 "
   "has a deduced return type and is not yet defined">;
 def note_defaulted_comparison_cannot_deduce_undeduced_auto : Note<
   "%select{|member|base class}0 %1 declared here">;
 def note_defaulted_comparison_cannot_deduce_callee : Note<
   "selected 'operator<=>' for %select{|member|base class}0 %1 declared here">;
-def note_defaulted_comparison_selected_invalid : Note<
-  "would compare %select{|member|base class}0 %1 "
-  "as %2, which does not support relational comparisons">;
 def err_incorrect_defaulted_comparison_constexpr : Error<
   "defaulted definition of %select{%sub{select_defaulted_comparison_kind}1|"
   "three-way comparison operator}0 "
   "cannot be declared %select{constexpr|consteval}2 because "
   "%select{it|the corresponding implicit 'operator=='}0 "
   "invokes a non-constexpr comparison function">;
 def note_defaulted_comparison_not_constexpr : Note<
   "non-constexpr comparison function would be used to compare "

clang/lib/Sema/SemaDeclCXX.cpp

case OR_Success: {
         }
       } else {
         QualType T = Best->BuiltinParamTypes[0];
         assert(T == Best->BuiltinParamTypes[1] &&
                "builtin comparison for different types?");
         assert(Best->BuiltinParamTypes[2].isNull() &&
                "invalid builtin comparison");
 
-        // The builtin operator for relational comparisons on function
-        // pointers is the only known case which cannot be used.
-        if (OO != OO_EqualEqual && T->isFunctionPointerType()) {
-          if (Diagnose == ExplainDeleted)
-            S.Diag(Subobj.Loc, diag::note_defaulted_comparison_selected_invalid)
-                << Subobj.Kind << Subobj.Decl << T;
-          return Result::deleted();
-        }
-
         if (NeedsDeducing) {
           Optional<ComparisonCategoryType> Cat =
               getComparisonCategoryForBuiltinCmp(T);
           assert(Cat && "no category for builtin comparison?");
           R.Category = *Cat;
         }
       }
 

clang/lib/Sema/SemaExpr.cpp

if (!IsOrdered && LHSIsNull != RHSIsNull) {
     if (RHSIsNull)
       DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality,
                                    RHS.get()->getSourceRange());
     else
       DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality,
                                    LHS.get()->getSourceRange());
   }
 
+  if (IsOrdered && LHSType->isFunctionPointerType() &&
+      RHSType->isFunctionPointerType()) {
+    // Valid unless a relational comparison of function pointers
+    bool IsError = getLangOpts().CPlusPlus;
+    Diag(Loc, IsError
+                  ? diag::err_typecheck_ordered_comparison_of_function_pointers
+                  : diag::ext_typecheck_ordered_comparison_of_function_pointers)
+        << LHSType << RHSType << LHS.get()->getSourceRange()
+        << RHS.get()->getSourceRange();
+    if (IsError)
+      return Opc != BO_Cmp ? Context.getLogicalOperationType() : QualType();
+  }
+
   if ((LHSType->isIntegerType() && !LHSIsNull) ||
       (RHSType->isIntegerType() && !RHSIsNull)) {
     // Skip normal pointer conversion checks in this case; we have better
     // diagnostics for this below.
   } else if (getLangOpts().CPlusPlus) {
     // Equality comparison of a function pointer to a void pointer is invalid,
     // but we allow it as an extension.
     // FIXME: If we really want to allow this, should it be part of composite
if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
         if ((LCanPointeeTy->isIncompleteType() !=
              RCanPointeeTy->isIncompleteType()) &&
             !getLangOpts().C11) {
           Diag(Loc, diag::ext_typecheck_compare_complete_incomplete_pointers)
               << LHS.get()->getSourceRange() << RHS.get()->getSourceRange()
               << LHSType << RHSType << LCanPointeeTy->isIncompleteType()
               << RCanPointeeTy->isIncompleteType();
         }
-        if (LCanPointeeTy->isFunctionType()) {
-          // Valid unless a relational comparison of function pointers
-          Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
-              << LHSType << RHSType << LHS.get()->getSourceRange()
-              << RHS.get()->getSourceRange();
-        }
       }
     } else if (!IsRelational &&
                (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
       // Valid unless comparison between non-null pointer and function pointer
       if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
           && !LHSIsNull && !RHSIsNull)
         diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
                                                 /*isError*/false);

clang/lib/Sema/SemaOverload.cpp

public:
   //
   //        bool       operator<(T, T);
   //        bool       operator>(T, T);
   //        bool       operator<=(T, T);
   //        bool       operator>=(T, T);
   //        bool       operator==(T, T);
   //        bool       operator!=(T, T);
   //           R       operator<=>(T, T)
-  void addGenericBinaryPointerOrEnumeralOverloads() {
+  void addGenericBinaryPointerOrEnumeralOverloads(bool IsOrdered) {
     // C++ [over.match.oper]p3:
     //   [...]the built-in candidates include all of the candidate operator
     //   functions defined in 13.6 that, compared to the given operator, [...]
     //   do not have the same parameter-type-list as any non-template non-member
     //   candidate.
     //
     // Note that in practice, this only affects enumeration types because there
     // aren't any built-in candidates of record type, and a user-defined operator
void addGenericBinaryPointerOrEnumeralOverloads(bool IsOrdered) {
     /// Set of (canonical) types that we've already handled.
     llvm::SmallPtrSet<QualType, 8> AddedTypes;
 
     for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
       for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
         // Don't add the same builtin candidate twice.
         if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
           continue;
+        if (IsOrdered && PtrTy->isFunctionPointerType())
+          continue;
 
         QualType ParamTypes[2] = {PtrTy, PtrTy};
         S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
       }
       for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
         CanQualType CanonType = S.Context.getCanonicalType(EnumTy);
 
         // Don't add the same builtin candidate twice, or if a user defined
public:
   //      LR         operator&(L, R);
   //      LR         operator^(L, R);
   //      LR         operator|(L, R);
   //      L          operator<<(L, R);
   //      L          operator>>(L, R);
   //
   //   where LR is the result of the usual arithmetic conversions
   //   between types L and R.
-  void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
+  void addBinaryBitwiseArithmeticOverloads() {
     if (!HasArithmeticOrEnumeralCandidateType)
       return;
 
     for (unsigned Left = FirstPromotedIntegralType;
          Left < LastPromotedIntegralType; ++Left) {
       for (unsigned Right = FirstPromotedIntegralType;
            Right < LastPromotedIntegralType; ++Right) {
         QualType LandR[2] = { ArithmeticTypes[Left],
void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
   case OO_MinusMinus:
     OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
     OpBuilder.addPlusPlusMinusMinusPointerOverloads();
     break;
 
   case OO_EqualEqual:
   case OO_ExclaimEqual:
     OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
-    LLVM_FALLTHROUGH;
+    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(false);
+    OpBuilder.addGenericBinaryArithmeticOverloads();
+    break;
 
   case OO_Less:
   case OO_Greater:
   case OO_LessEqual:
   case OO_GreaterEqual:
-    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
+    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(true);
     OpBuilder.addGenericBinaryArithmeticOverloads();
     break;
 
   case OO_Spaceship:
-    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
+    OpBuilder.addGenericBinaryPointerOrEnumeralOverloads(true);
     OpBuilder.addThreeWayArithmeticOverloads();
     break;
 
   case OO_Percent:
   case OO_Caret:
   case OO_Pipe:
   case OO_LessLess:
   case OO_GreaterGreater:
-    OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
+    OpBuilder.addBinaryBitwiseArithmeticOverloads();
     break;
 
   case OO_Amp: // '&' is either unary or binary
     if (Args.size() == 1)
       // C++ [over.match.oper]p3:
       //   -- For the operator ',', the unary operator '&', or the
       //      operator '->', the built-in candidates set is empty.
       break;
 
-    OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
+    OpBuilder.addBinaryBitwiseArithmeticOverloads();
     break;
 
   case OO_Tilde:
     OpBuilder.addUnaryTildePromotedIntegralOverloads();
     break;
 
   case OO_Equal:
     OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();

clang/test/CXX/class/class.compare/class.spaceship/p2.cpp

struct D {
     // expected-error@+1 {{deduced return type for defaulted three-way comparison operator must be 'auto', not 'CmpCat auto'}}
     friend CmpCat auto operator<=>(const D&, const D&) = default;
   };
 }
 
 namespace PR48856 {
   struct A {
     auto operator<=>(const A &) const = default; // expected-warning {{implicitly deleted}}
-    void (*x)();                                 // expected-note {{does not support relational comparisons}}
+    void (*x)();                                 // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 
   struct B {
     auto operator<=>(const B &) const = default; // expected-warning {{implicitly deleted}}
     void (B::*x)();                              // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 
   struct C {
namespace PR50591 {
   std::partial_ordering cmp_b2 = b2() <=> b2();
 
   struct a3 {
     using fp = void (*)();
     operator fp() const;
   };
   struct b3 {
     auto operator<=>(b3 const &) const = default; // expected-warning {{implicitly deleted}}
-    a3 f; // expected-note {{would compare member 'f' as 'void (*)()', which does not support relational comparisons}}
+    a3 f;                                         // expected-note {{because there is no viable three-way comparison function}}
   };
 }

clang/test/CXX/drs/dr15xx.cpp

#endif
     composite_pointer_type_is_ord<const B*, volatile A*, const volatile A*>();
 
     composite_pointer_type_is_unord<const int *A::*, volatile int *B::*, const volatile int *const B::*>();
     composite_pointer_type_is_unord<const int *B::*, volatile int *A::*, const volatile int *const B::*>();
     no_composite_pointer_type<int (A::*)(), int (C::*)()>();
     no_composite_pointer_type<const int (A::*)(), volatile int (C::*)()>();
 
 #if __cplusplus > 201402
-    composite_pointer_type_is_ord<int (*)() noexcept, int (*)(), int (*)()>();
-    composite_pointer_type_is_ord<int (*)(), int (*)() noexcept, int (*)()>();
+    composite_pointer_type_is_unord<int (*)() noexcept, int (*)(), int (*)()>();
+    composite_pointer_type_is_unord<int (*)(), int (*)() noexcept, int (*)()>();
     composite_pointer_type_is_unord<int (A::*)() noexcept, int (A::*)(), int (A::*)()>();
     composite_pointer_type_is_unord<int (A::*)(), int (A::*)() noexcept, int (A::*)()>();
     // FIXME: This looks like a standard defect; these should probably all have type 'int (B::*)()'.
     composite_pointer_type_is_unord<int (B::*)(), int (A::*)() noexcept, int (B::*)()>();
     composite_pointer_type_is_unord<int (A::*)() noexcept, int (B::*)(), int (B::*)()>();
     composite_pointer_type_is_unord<int (B::*)() noexcept, int (A::*)(), int (B::*)()>();
     composite_pointer_type_is_unord<int (A::*)(), int (B::*)() noexcept, int (B::*)()>();
 

clang/test/CXX/drs/dr3xx.cpp

 
 namespace dr301 { // dr301: yes
   // see also dr38
   struct S;
   template<typename T> void operator+(T, T);
   void operator-(S, S);
 
   void f() {
-    bool a = (void(*)(S, S))operator+<S> <
+    bool a = (void(*)(S, S))operator+<S> < // expected-error {{ordered comparison of function pointers}}
              (void(*)(S, S))operator+<S>;
-    bool b = (void(*)(S, S))operator- < // cxx20_2b-note {{to match this '<'}}
+    bool b = (void(*)(S, S))operator- < // cxx20_2b-note {{to match this '<'}} cxx98_17-error {{ordered comparison of function pointers}}
              (void(*)(S, S))operator-; // cxx20_2b-error {{expected '>'}}
     bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}}
              (void(*)(S, S))operator-; // expected-error {{expected '>'}}
   }
 
   template<typename T> void f() {
     typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
     // FIXME: This shouldn't say (null).

clang/test/CXX/expr/expr.const/p2-0x.cpp

namespace UnspecifiedRelations {
   constexpr bool u8 = p >= (int*)0; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
   constexpr bool u9 = (int*)0 < q; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
   constexpr bool u10 = (int*)0 <= q; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
   constexpr bool u11 = (int*)0 > q; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
   constexpr bool u12 = (int*)0 >= q; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
   void f(), g();
 
   constexpr void (*pf)() = &f, (*pg)() = &g;
-  constexpr bool u13 = pf < pg; // expected-error {{constant expression}} expected-note {{comparison has unspecified value}}
-  constexpr bool u14 = pf == pg;
+  constexpr bool u13 = pf == pg;
 
   // If two pointers point to non-static data members of the same object with
   // different access control, the result is unspecified.
   struct A {
   public:
     constexpr A() : a(0), b(0) {}
     int a;
     constexpr bool cmp() const { return &a < &b; } // expected-note {{comparison of address of fields 'a' and 'b' of 'A' with differing access specifiers (public vs private) has unspecified value}}

clang/test/FixIt/fixit.cpp

namespace greatergreater {
   };
 
   template<template<typename>> struct TemplateTemplateParam; // expected-error {{requires 'class'}}
 
   template<typename T> void t();
   void g() {
     void (*p)() = &t<int>;
     (void)(&t<int>==p); // expected-error {{use '> ='}}
-    (void)(&t<int>>=p); // expected-error {{use '> >'}}
 #if __cplusplus < 201103L
-    (void)(&t<S<int>>>=p); // expected-error {{use '> >'}}
     (Shr)&t<S<int>>>>=p; // expected-error {{use '> >'}}
 #endif
 
     // FIXME: We correct this to '&t<int> > >= p;' not '&t<int> >>= p;'
     //(Shr)&t<int>>>=p;
 
     // FIXME: The fix-its here overlap.
     //(void)(&t<S<int>>==p);

clang/test/Parser/cxx-template-argument.cpp

 // Test behavior when a template-id is ended by a token which starts with '>'.
 namespace greatergreater {
   template<typename T> struct S { S(); S(T); };
   void f(S<int>=0); // expected-error {{a space is required between a right angle bracket and an equals sign (use '> =')}}
   void f(S<S<int>>=S<int>()); // expected-error {{use '> >'}} expected-error {{use '> ='}}
   template<typename T> void t();
   void g() {
     void (*p)() = &t<int>;
-    (void)(&t<int>==p); // expected-error {{use '> ='}}
-    (void)(&t<int>>=p); // expected-error {{use '> >'}}
-    (void)(&t<S<int>>>=p);
+    (void)(&t<int>==p);    // expected-error {{use '> ='}}
+    (void)(&t<int>>=p);    // expected-error {{use '> >'}} expected-error {{ordered comparison of function pointers}}
+    (void)(&t<S<int>>>=p); // expected-error {{ordered comparison of function pointers}}
 #if __cplusplus <= 199711L
     // expected-error@-2 {{use '> >'}}
 #endif
     (void)(&t<S<int>>==p); // expected-error {{use '> >'}} expected-error {{use '> ='}}
   }
 }
 
 namespace PR5925 {

clang/test/Sema/compare.c

int pointers(int *a) {
   return a > 0; // expected-warning {{ordered comparison between pointer and zero ('int *' and 'int') is an extension}}
   return a > 42; // expected-warning {{ordered comparison between pointer and integer ('int *' and 'int')}}
   return a > (void *)0; // expected-warning {{comparison of distinct pointer types}}
 }
 
 int function_pointers(int (*a)(int), int (*b)(int), void (*c)(int)) {
   return a > b; // expected-warning {{ordered comparison of function pointers}}
   return function_pointers > function_pointers; // expected-warning {{self-comparison always evaluates to false}} expected-warning{{ordered comparison of function pointers}}
-  return a > c; // expected-warning {{comparison of distinct pointer types}}
+  return a > c; // expected-warning {{comparison of distinct pointer types}} expected-warning {{ordered comparison of function pointers}}
   return a == (void *) 0;
   return a == (void *) 1; // expected-warning {{equality comparison between function pointer and void pointer}}
 }
 
 int void_pointers(void* foo) {
   return foo == (void*) 0;
   return foo == (void*) 1;
 }

clang/test/SemaCXX/compare-cxx2a.cpp

 }
 
 using nullptr_t = decltype(nullptr);
 
 struct Class {};
 struct ClassB : Class {};
 struct Class2 {};
 using FnTy = void(int);
-using FnTy2 = long(int);
-using FnTy3 = void(int) noexcept;
 using MemFnTy = void (Class::*)() const;
 using MemDataTy = long(Class::*);
 
 void test_nullptr(int *x, FnTy *fp, MemFnTy memp, MemDataTy memdp) {
   auto r1 = (nullptr <=> nullptr); // expected-error {{invalid operands}}
   auto r2 = (nullptr <=> x); // expected-error {{invalid operands}}
   auto r3 = (fp <=> nullptr); // expected-error {{invalid operands}}
   auto r4 = (0 <=> fp); // expected-error {{ordered comparison between pointer and zero}}
   auto r5 = (nullptr <=> memp); // expected-error {{invalid operands}}
   auto r6 = (0 <=> memdp); // expected-error {{invalid operands}}
   auto r7 = (0 <=> nullptr); // expected-error {{invalid operands}}
 }
 
 void test_memptr(MemFnTy mf, MemDataTy md) {
   (void)(mf <=> mf); // expected-error {{invalid operands}} expected-warning {{self-comparison}}
   (void)(md <=> md); // expected-error {{invalid operands}} expected-warning {{self-comparison}}
 }
 
-void test_compatible_pointer(FnTy *f1, FnTy2 *f2, FnTy3 *f3) {
-  (void)(f1 <=> f2); // expected-error {{distinct pointer types}}
-  (void)(f1 <=> f3); // expected-error {{invalid operands}}
-}
-
 // Test that variable narrowing is deferred for value dependent expressions
 template <int Val>
 auto test_template_overflow() {
   // expected-error@+1 {{argument to 'operator<=>' evaluates to -1, which cannot be narrowed to type 'unsigned long'}}
   return (Val <=> (unsigned long)0);
 }
 template auto test_template_overflow<0>();
 template auto test_template_overflow<-1>(); // expected-note {{requested here}}

clang/test/SemaCXX/compare-function-pointer.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
+
+using fp_t = void (*)();
+extern fp_t a, b;
+
+bool eq = a == b;
+bool ne = a != b;
+bool lt = a < b;   // expected-error {{ordered comparison of function pointers ('fp_t' (aka 'void (*)()') and 'fp_t')}}
+bool le = a <= b;  // expected-error {{ordered comparison of function pointers}}
+bool gt = a > b;   // expected-error {{ordered comparison of function pointers}}
+bool ge = a >= b;  // expected-error {{ordered comparison of function pointers}}
+bool tw = a <=> b; // expected-error {{ordered comparison of function pointers}}

clang/test/SemaTemplate/resolve-single-template-id.cpp

int main()
   (twoT<int>) == oneT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
   bool b = oneT<int>; // expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
   void (*p)() = oneT<int>;
   test<oneT<int> > ti;
   void (*u)(int) = oneT<int>;
 
   b = (void (*)()) twoT<int>;
   
-  one < one; //expected-warning {{self-comparison always evaluates to false}} \
-             //expected-warning {{relational comparison result unused}}         
+  one < one; // expected-warning {{self-comparison always evaluates to false}} \
+             // expected-warning {{relational comparison result unused}}       \
+             // expected-error   {{ordered comparison of function pointers}}
 
-  oneT<int> < oneT<int>;  //expected-warning {{self-comparison always evaluates to false}} \
-                          //expected-warning {{relational comparison result unused}}
+  oneT<int> < oneT<int>;  // expected-warning {{self-comparison always evaluates to false}} \
+                          // expected-warning {{relational comparison result unused}}       \
+                          // expected-error   {{ordered comparison of function pointers}}
 
   two < two; //expected-error 2 {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{invalid operands to binary expression ('void' and 'void')}}
   twoT<int> < twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
   oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
                     // expected-note {{use '=' to turn this equality comparison into an assignment}} \
                     // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
                     // expected-note {{prefix with the address-of operator to silence this warning}}
 
 }
 
 struct rdar9108698 {
   template<typename> void f(); // expected-note{{possible target for call}}

compiler-rt/test/asan/TestCases/Posix/coverage-module-unloaded.cpp

 // Check that unloading a module doesn't break coverage dumping for remaining
 // modules.
 // RUN: %clangxx_asan -fsanitize-coverage=func,trace-pc-guard -DSHARED %s -shared -o %dynamiclib1 -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func,trace-pc-guard -DSHARED %s -shared -o %dynamiclib2 -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func,trace-pc-guard %s %libdl -o %t.exe
 // RUN: mkdir -p %t.tmp/coverage-module-unloaded && cd %t.tmp/coverage-module-unloaded
 // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t.exe %dynamiclib1 %dynamiclib2 2>&1        | FileCheck %s
 // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t.exe %dynamiclib1 %dynamiclib2 foo 2>&1    | FileCheck %s
 //
 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
 // XFAIL: android
 // UNSUPPORTED: ios
 
 #include <assert.h>
 #include <dlfcn.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #ifdef SHARED
 extern "C" {
 void bar() { printf("bar\n"); }
 }
 #else
int main(int argc, char **argv) {
   void *handle2 = dlopen(argv[2], RTLD_LAZY);  // %dynamiclib2
   assert(handle2);
   void (*bar2)() = (void (*)())dlsym(handle2, "bar");
   assert(bar2);
   bar2();
 
   // It matters whether the unloaded module has a higher or lower address range
   // than the remaining one. Make sure to test both cases.
+  bool lt = reinterpret_cast<uintptr_t>(bar1) < reinterpret_cast<uintptr_t>(bar2);
   if (argc < 2)
-    dlclose(bar1 < bar2 ? handle1 : handle2);
+    dlclose(lt ? handle1 : handle2);
   else
-    dlclose(bar1 < bar2 ? handle2 : handle1);
+    dlclose(lt ? handle2 : handle1);
   return 0;
 }
 #endif
 
 // CHECK: PID: [[PID:[0-9]+]]
 // CHECK-DAG: exe{{.*}}[[PID]].sancov: {{.*}}PCs written
 // CHECK-DAG: dynamic{{.*}}[[PID]].sancov: {{.*}}PCs written