[Clang] Do not use memcpy for scalable struct copy.

[HsiangKai]

Summary

For scalable struct types, we do not know the exact size of the struct. Do not use memcpy for struct copy. We use extractvalue and insertvalue for the purpose.

[frasercrmck]

clang/include/clang/AST/Type.h

4627

nit: missing "a": is a sizeless type

clang/lib/CodeGen/CGExprAgg.cpp

2085

Are SrcVec and DestVec the right names here? It took me a while to realise they're not vector types.

2086

We could define Vec inside the loop?

2088

I don't know if getContext().getASTRecordLayout(Record).getFieldCount() is expensive to compute, but this may be recomputing it on every iteration.

[HsiangKai]

Address comments.

clang/include/clang/AST/Type.h

public:
   RecordDecl *getDecl() const {
     return reinterpret_cast<RecordDecl*>(TagType::getDecl());
   }
 
   /// Recursively check all fields in the record for const-ness. If any field
   /// is declared const, return true. Otherwise, return false.
   bool hasConstFields() const;
 
+  /// Recursively check all fields in the record for sizeless. If any field
+  /// is a sizeless type, return true. Otherwise, return false.
+  bool hasSizelessFields() const;
+
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 
   static bool classof(const Type *T) { return T->getTypeClass() == Record; }
 };
 
 /// A helper class that allows the use of isa/cast/dyncast
 /// to detect TagType objects of enums.

clang/lib/AST/Type.cpp

for (FieldDecl *FD :
           RecordTypeList.push_back(FieldRecTy);
       }
     }
     ++NextToCheckIndex;
   }
   return false;
 }
 
+bool RecordType::hasSizelessFields() const {
+  std::vector<const RecordType *> RecordTypeList;
+  RecordTypeList.push_back(this);
+  unsigned NextToCheckIndex = 0;
+
+  while (RecordTypeList.size() > NextToCheckIndex) {
+    for (FieldDecl *FD :
+         RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
+      QualType FieldTy = FD->getType();
+      if (FieldTy.getTypePtr()->isSizelessType())
+        return true;
+      FieldTy = FieldTy.getCanonicalType();
+      if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) {
+        if (llvm::find(RecordTypeList, FieldRecTy) == RecordTypeList.end())
+          RecordTypeList.push_back(FieldRecTy);
+      }
+    }
+    ++NextToCheckIndex;
+  }
+  return false;
+}
+
 bool AttributedType::isQualifier() const {
   // FIXME: Generate this with TableGen.
   switch (getAttrKind()) {
   // These are type qualifiers in the traditional C sense: they annotate
   // something about a specific value/variable of a type.  (They aren't
   // always part of the canonical type, though.)
   case attr::ObjCGC:
   case attr::ObjCOwnership:

clang/lib/CodeGen/CGExprAgg.cpp

if (Ty->isCUDADeviceBuiltinSurfaceType()) {
         return;
     } else if (Ty->isCUDADeviceBuiltinTextureType()) {
       if (getTargetHooks().emitCUDADeviceBuiltinTextureDeviceCopy(*this, Dest,
                                                                   Src))
         return;
     }
   }
 
+  // Aggregate assignment turns into element-by-element copy.
+  if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
+    if (RecordTy->hasSizelessFields()) {
+      RecordDecl *Record = RecordTy->getDecl();
+      llvm::Value *SrcAgg = Builder.CreateLoad(SrcPtr);
+      llvm::Value *DestAgg = llvm::UndefValue::get(ConvertType(Ty));
+      unsigned FieldCount =
+          getContext().getASTRecordLayout(Record).getFieldCount();
+      for (unsigned I = 0; I < FieldCount; ++I) {
+        llvm::Value *Vec = Builder.CreateExtractValue(SrcAgg, I);
+        DestAgg = Builder.CreateInsertValue(DestAgg, Vec, I);
+      }
+      Builder.CreateStore(DestAgg, DestPtr);
+      return;
+    }
+  }
+
   // Aggregate assignment turns into llvm.memcpy.  This is almost valid per
   // C99 6.5.16.1p3, which states "If the value being stored in an object is
   // read from another object that overlaps in anyway the storage of the first
   // object, then the overlap shall be exact and the two objects shall have
   // qualified or unqualified versions of a compatible type."
   //
   // memcpy is not defined if the source and destination pointers are exactly
   // equal, but other compilers do this optimization, and almost every memcpy