fixes copy constructor generation of classes containing 0-length arrays followed by exactly 1 trivial field (fixes #40682)

[lebedev.ri]

Test?

[jbigalet]

Fixes #40682

[jbigalet]

@lebedev.ri not a test, did I forgot to add anything? (sorry, it's my first time here)

[jbigalet]

regression test

[rjmccall]

Ah, thanks, seems like a reasonable fix.

[jbigalet]

Thanks!
I don't have commit rights btw

[rjmccall]

Committed as r358115.

clang/lib/CodeGen/CGClass.cpp

void addNextField(FieldDecl *F) {
 
       // The 'first' and 'last' fields are chosen by offset, rather than field
       // index. This allows the code to support bitfields, as well as regular
       // fields.
       uint64_t FOffset = RecLayout.getFieldOffset(F->getFieldIndex());
       if (FOffset < FirstFieldOffset) {
         FirstField = F;
         FirstFieldOffset = FOffset;
-      } else if (FOffset > LastFieldOffset) {
+      } else if (FOffset >= LastFieldOffset) {
         LastField = F;
         LastFieldOffset = FOffset;
       }
     }
 
     const VarDecl *SrcRec;
     const ASTRecordLayout &RecLayout;
     FieldDecl *FirstField;

clang/test/CodeGenCXX/pod-member-memcpys.cpp

 struct ArrayMember {
   int a, b, c, d;
   int e[12];
   NonPOD np;
   int f[12];
   int w, x, y, z;
 };
 
+struct ZeroLengthArrayMember {
+    NonPOD np;
+    int a;
+    int b[0];
+    int c;
+};
+
 struct VolatileMember {
   int a, b, c, d;
   volatile int v;
   NonPOD np;
   int w, x, y, z;
 };
 
 struct BitfieldMember {

 // Assignment operators are output in the order they're encountered.
 
 #define CALL_AO(T) void callAO##T(T& a, const T& b) { a = b; } 
 
 CALL_AO(Basic)
 CALL_AO(PODMember)
 CALL_AO(PODLikeMember)
 CALL_AO(ArrayMember)
+CALL_AO(ZeroLengthArrayMember)
 CALL_AO(VolatileMember)
 CALL_AO(BitfieldMember)
 CALL_AO(InnerClassMember)
 CALL_AO(PackedMembers)
 
 // Basic copy-assignment:
 // CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.Basic* @_ZN5BasicaSERKS_(%struct.Basic* %this, %struct.Basic* dereferenceable({{[0-9]+}}))
 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})

 
 // ArrayMember copy-assignment:
 // CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ArrayMember* @_ZN11ArrayMemberaSERKS_(%struct.ArrayMember* %this, %struct.ArrayMember* dereferenceable({{[0-9]+}}))
 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
 // CHECK: call dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
 // CHECK: ret %struct.ArrayMember*
 
+// ZeroLengthArrayMember copy-assignment:
+// CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.ZeroLengthArrayMember* @_ZN21ZeroLengthArrayMemberaSERKS_(%struct.ZeroLengthArrayMember* %this, %struct.ZeroLengthArrayMember* dereferenceable({{[0-9]+}}))
+// CHECK: call dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 8, i1 {{.*}})
+// CHECK: ret %struct.ZeroLengthArrayMember*
+
 // VolatileMember copy-assignment:
 // CHECK-LABEL: define linkonce_odr dereferenceable({{[0-9]+}}) %struct.VolatileMember* @_ZN14VolatileMemberaSERKS_(%struct.VolatileMember* %this, %struct.VolatileMember* dereferenceable({{[0-9]+}}))
 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
 // CHECK: load volatile i32, i32* {{.*}}, align 4
 // CHECK: store volatile i32 {{.*}}, align 4
 // CHECK: call dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
 // CHECK: ret %struct.VolatileMember*