[clang][CodeGen] Avoid emitting unnecessary memcpy of records without content

[strimo378]

Summary

Clang codegen emits unnecessary memcpy for C++ records without content. This patch fixes the issue.

See https://github.com/llvm/llvm-project/issues/59336

Please let me know if the patch is going into the right direction and has a change to get accepted. If yes, I'll finish it with test cases and also extend it to C. Currently, check-clang is not showing an error...

[efriedma]

This looks sort of similar to CodeGen::isEmptyRecord... but I guess it's not quite the same thing. (Even if a struct isn't "empty" in the ABI sense, there still might not be anything to copy.)

Instead of looking for zero-length bitfields, you probably want to just check isUnnamedBitfield()? Unnamed bitfields are just padding, whether or not they're zero-length.

clang/lib/CodeGen/CGExprAgg.cpp

if (Layout.getBaseClassOffset(BaseRD) +
           getContext().getASTRecordLayout(BaseRD).getSize() <=
       Layout.getNonVirtualSize())
     return AggValueSlot::DoesNotOverlap;
 
   // The tail padding may contain values we need to preserve.
   return AggValueSlot::MayOverlap;
 }
 
+static bool hasSomethingToCopy(const ASTContext &Ctx, QualType Ty) {
+  if (const RecordType *RT = Ty->getAs<RecordType>()) {
+    CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
+
+    if (Record->isEmpty())
+      return false;
+    if (Record->isDynamicClass())
+      return true;
+
+    for (auto *Field : Record->fields()) {
+      if (Field->isZeroLengthBitField(Ctx))
+        continue;
+
+      if (hasSomethingToCopy(Ctx, Field->getType()))
+        return true;
+    }
+
+    for (auto &Base : Record->bases()) {
+      if (hasSomethingToCopy(Ctx, Base.getType()))
+        return true;
+    }
+
+    return false;
+  } else {
+    return true;
+  }
+}
+
 void CodeGenFunction::EmitAggregateCopy(LValue Dest, LValue Src, QualType Ty,
                                         AggValueSlot::Overlap_t MayOverlap,
                                         bool isVolatile) {
   assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
 
   Address DestPtr = Dest.getAddress(*this);
   Address SrcPtr = Src.getAddress(*this);
 
   if (getLangOpts().CPlusPlus) {
     if (const RecordType *RT = Ty->getAs<RecordType>()) {
       CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
       assert((Record->hasTrivialCopyConstructor() ||
               Record->hasTrivialCopyAssignment() ||
               Record->hasTrivialMoveConstructor() ||
               Record->hasTrivialMoveAssignment() ||
               Record->hasAttr<TrivialABIAttr>() || Record->isUnion()) &&
              "Trying to aggregate-copy a type without a trivial copy/move "
              "constructor or assignment operator");
       // Ignore empty classes in C++.
-      if (Record->isEmpty())
+      if (!hasSomethingToCopy(getContext(), Ty))
         return;
     }
   }
 
   if (getLangOpts().CUDAIsDevice) {
     if (Ty->isCUDADeviceBuiltinSurfaceType()) {
       if (getTargetHooks().emitCUDADeviceBuiltinSurfaceDeviceCopy(*this, Dest,
                                                                   Src))