This is an archive of the discontinued LLVM Phabricator instance.

Differential D146329

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

Authored by shafik on Mar 17 2023, 1:45 PM.

Details

Reviewers
aaron.ballman
erichkeane
rsmith
Commits
rG6d0fab467efb: [Clang] Fix defaulted equality operator so that it does not attempt to compare…
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

Diff Detail

Unit TestsFailed

TimeTest
4,520 msx64 debian > AddressSanitizer-x86_64-linux.TestCases/Linux::auto_memory_profile_test.cpp

Event Timeline

shafik created this revision.Mar 17 2023, 1:45 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 17 2023, 1:45 PM
shafik requested review of this revision.Mar 17 2023, 1:45 PM

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.

Harbormaster completed remote builds in B220143: Diff 506192.Mar 17 2023, 2:47 PM
royjacobson added a subscriber: royjacobson.EditedMar 20 2023, 2:16 PM
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 added a comment.Apr 3 2023, 9:06 PM
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 added a comment.Apr 4 2023, 6:34 AM
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 updated this revision to Diff 512983.Apr 12 2023, 3:19 PM
  • Added codegen test
shafik added a comment.Apr 12 2023, 3:20 PM

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

Harbormaster completed remote builds in B225191: Diff 512983.Apr 12 2023, 4:19 PM
erichkeane added inline comments.Apr 13 2023, 5:56 AM
clang/test/CodeGenCXX/defaulted_equality_ignore_unnamed_bitfields.cpp
24

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 updated this revision to Diff 513345.Apr 13 2023, 1:36 PM
shafik marked an inline comment as done.
  • Update codegen test based on feedback
Harbormaster completed remote builds in B225431: Diff 513345.Apr 13 2023, 3:17 PM
erichkeane accepted this revision.Apr 14 2023, 5:49 AM
This revision is now accepted and ready to land.Apr 14 2023, 5:49 AM
shafik updated this revision to Diff 513754.Apr 14 2023, 2:55 PM
  • Add release note
This revision was landed with ongoing or failed builds.Apr 14 2023, 3:01 PM
Closed by commit rG6d0fab467efb: [Clang] Fix defaulted equality operator so that it does not attempt to compare… (authored by shafik). · Explain Why
This revision was automatically updated to reflect the committed changes.
shafik added a commit: rG6d0fab467efb: [Clang] Fix defaulted equality operator so that it does not attempt to compare….
Herald added a project: Restricted Project. · View Herald TranscriptApr 14 2023, 3:01 PM
Harbormaster completed remote builds in B225735: Diff 513754.Apr 14 2023, 4:12 PM

Revision Contents

PathSize
clang/
lib/
Sema/
4 lines
test/
CXX/
class/
class.compare/
class.compare.default/
23 lines
CodeGenCXX/
44 lines

Diff 513345

clang/lib/Sema/SemaDeclCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,749 Lines • ▼ Show 20 Lines bool visitSubobjects(ResultList &Results, CXXRecordDecl *Record,
for (CXXBaseSpecifier &Base : Record->bases()) for (CXXBaseSpecifier &Base : Record->bases())
if (Results.add(getDerived().visitSubobject( if (Results.add(getDerived().visitSubobject(
S.Context.getQualifiedType(Base.getType(), Quals), S.Context.getQualifiedType(Base.getType(), Quals),
getDerived().getBase(&Base)))) getDerived().getBase(&Base))))
return true; return true;
// followed by the non-static data members of C // followed by the non-static data members of C
for (FieldDecl *Field : Record->fields()) { for (FieldDecl *Field : Record->fields()) {
// C++23 [class.bit]p2:
// Unnamed bit-fields are not members ...
if (Field->isUnnamedBitfield())
continue;
// Recursively expand anonymous structs. // Recursively expand anonymous structs.
if (Field->isAnonymousStructOrUnion()) { if (Field->isAnonymousStructOrUnion()) {
if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(), if (visitSubobjects(Results, Field->getType()->getAsCXXRecordDecl(),
Quals)) Quals))
return true; return true;
continue; continue;
} }
▲ Show 20 Lines • Show All 10,856 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 220 Lines • ▼ Show 20 Lines
void f2() { void f2() {
S7<int> a; // expected-note{{S7<int>' requested}} S7<int> a; // expected-note{{S7<int>' requested}}
S7<evil> b; S7<evil> b;
(void)(a == 0); // expected-error{{invalid operands}} (void)(a == 0); // expected-error{{invalid operands}}
(void)(b == 0); (void)(b == 0);
} }
} // namespace p2085_2 } // 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
}
}

clang/test/CodeGenCXX/defaulted_equality_ignore_unnamed_bitfields.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++20 %s -triple x86_64-linux -emit-llvm -o - | FileCheck %s
// GH61417
// Check that we don't attempt to compare the unnamed bitfields
struct A {
unsigned x : 1;
unsigned : 1;
friend bool operator==(A, A);
};
struct B {
unsigned x : 1;
unsigned : 31;
friend bool operator==(B, B);
};
bool operator==(A, A) = default;
// CHECK: define{{.*}} @_Zeq1AS_
// CHECK: %[[LHS:.+]] = alloca %struct.A, align 4
// CHECK: %[[RHS:.+]] = alloca %struct.A, align 4
// CHECK: %[[LHS_LOAD:.+]] = load i8, ptr %[[LHS]], align 4
erichkeaneUnsubmitted
Done
ReplyInline Actions

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.

erichkeane: I think these check lines aren't nearly specific enough, i think it should have a handful of…
// CHECK: %[[LHS_CLEAR:.+]] = and i8 %[[LHS_LOAD]], 1
// CHECK: %[[LHS_CAST:.+]] = zext i8 %[[LHS_CLEAR]] to i32
// CHECK: %[[RHS_LOAD:.+]] = load i8, ptr %[[RHS]]
// CHECK: %[[RHS_CLEAR:.+]] = and i8 %[[RHS_LOAD]], 1
// CHECK: %[[RHS_CAST:.+]] = zext i8 %[[RHS_CLEAR]] to i32
// CHECK: %[[CMP:.*]] = icmp eq i32 %[[LHS_CAST]], %[[RHS_CAST]]
// CHECK: ret i1 %[[CMP]]
bool operator==(B, B) = default;
// CHECK: define{{.*}} @_Zeq1BS_
// CHECK: %[[LHS_B:.+]] = alloca %struct.B, align 4
// CHECK: %[[RHS_B:.+]] = alloca %struct.B, align 4
// CHECK: %[[LHS_LOAD_B:.+]] = load i32, ptr %[[LHS_B]], align 4
// CHECK: %[[LHS_CLEAR_B:.+]] = and i32 %[[LHS_LOAD_B]], 1
// CHECK: %[[RHS_LOAD_B:.+]] = load i32, ptr %[[RHS_B]]
// CHECK: %[[RHS_CLEAR_B:.+]] = and i32 %[[RHS_LOAD_B]], 1
// CHECK: %[[CMP_B:.*]] = icmp eq i32 %[[LHS_CLEAR_B]], %[[RHS_CLEAR_B]]
// CHECK: ret i1 %[[CMP_B]]