[Clang] Fix defaulted equality operator so that it does not attempt to compare unnamed bit-fields

[shafik]

Summary

If we look at class.bit p2 it tells us that that unnamed bit-fields are not members and class.compare.default p5 tells us that we should only non-static data members of the class.

This fixes: https://github.com/llvm/llvm-project/issues/61335 and https://github.com/llvm/llvm-project/issues/61417

[shafik]

I would have loved to test the case from https://github.com/llvm/llvm-project/issues/61335 directly but I think in order to do it nicely I need __builtin_memset to be usable in a constant expression context. I will add this to my todo list. I am open to other alternatives for testing this.

[royjacobson]

In D146329#4203174, @shafik wrote:

I would have loved to test the case from https://github.com/llvm/llvm-project/issues/61335 directly but I think in order to do it nicely I need __builtin_memset to be usable in a constant expression context. I will add this to my todo list. I am open to other alternatives for testing this.

I managed to generate relatively readable LLVM IR for this: https://godbolt.org/z/z1YzoEcr3 (the generated equality operators are obviously not correct yet), I think matching against that is testing the issue pretty well.

(The trick to making it readable was turning on optimization, though. Not sure if we usually do that)

[shafik]

In D146329#4207522, @royjacobson wrote:

In D146329#4203174, @shafik wrote:

I would have loved to test the case from https://github.com/llvm/llvm-project/issues/61335 directly but I think in order to do it nicely I need __builtin_memset to be usable in a constant expression context. I will add this to my todo list. I am open to other alternatives for testing this.

I managed to generate relatively readable LLVM IR for this: https://godbolt.org/z/z1YzoEcr3 (the generated equality operators are obviously not correct yet), I think matching against that is testing the issue pretty well.

(The trick to making it readable was turning on optimization, though. Not sure if we usually do that)

I think in general we can't rely on optimizations in test like this but wdyt @erichkeane

[erichkeane]

In D146329#4242215, @shafik wrote:

In D146329#4207522, @royjacobson wrote:

In D146329#4203174, @shafik wrote:

I would have loved to test the case from https://github.com/llvm/llvm-project/issues/61335 directly but I think in order to do it nicely I need __builtin_memset to be usable in a constant expression context. I will add this to my todo list. I am open to other alternatives for testing this.

I managed to generate relatively readable LLVM IR for this: https://godbolt.org/z/z1YzoEcr3 (the generated equality operators are obviously not correct yet), I think matching against that is testing the issue pretty well.

(The trick to making it readable was turning on optimization, though. Not sure if we usually do that)

I think in general we can't rely on optimizations in test like this but wdyt @erichkeane

We should not have opt enabled in our lit tests, thats correct. However, the non-optimized version of that godbolt link has reasonably readable IR that we can test.

[shafik]

• Added codegen test

[shafik]

@erichkeane let me know if the test I added is sufficient

[erichkeane]

clang/test/CodeGenCXX/defaulted_equality_ignore_unnamed_bitfields.cpp

23 ↗

(On Diff #512983)

I think these check lines aren't nearly specific enough, i think it should have a handful of CHECK lines confirming what we're doing, not just what we're not.

[shafik]

• Update codegen test based on feedback

[shafik]

• Add release note

clang/lib/Sema/SemaDeclCXX.cpp

bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
     for (CXXBaseSpecifier &Base : Record->bases())
       if (Results.add(getDerived().visitSubobject(
               S.Context.getQualifiedType(Base.getType(), Quals),
               getDerived().getBase(&Base))))
         return true;
 
     //   followed by the non-static data members of C
     for (FieldDecl *Field : Record->fields()) {
+      // C++23 [class.bit]p2:
+      //   Unnamed bit-fields are not members ...
+      if (Field->isUnnamedBitfield())
+        continue;
       // Recursively expand anonymous structs.
       if (Field->isAnonymousStructOrUnion()) {
         if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(),
                             Quals))
           return true;
         continue;
       }
 

clang/test/CXX/class/class.compare/class.compare.default/p1.cpp

 
 void f2() {
   S7<int> a; // expected-note{{S7<int>' requested}}
   S7<evil> b;
   (void)(a == 0); // expected-error{{invalid operands}}
   (void)(b == 0);
 }
 } // namespace p2085_2
+
+namespace GH61417 {
+struct A {
+  unsigned x : 1;
+  unsigned   : 0;
+  unsigned y : 1;
+
+  constexpr A() : x(0), y(0) {}
+  bool operator==(const A& rhs) const noexcept = default;
+};
+
+void f1() {
+  constexpr A a, b;
+  constexpr bool c = (a == b); // no diagnostic, we should not be comparing the
+                               // unnamed bit-field which is indeterminate
+}
+
+void f2() {
+    A a, b;
+    bool c = (a == b); // no diagnostic nor crash during codegen attempting to
+                       // access info for unnamed bit-field
+}
+}