[ADT] Silent warning related to memcpy of non trivially-copyable data

Author: serge-sans-paille

llvm/include/llvm/ADT/DenseMap.h

@@ -442,7 +442,8 @@ class DenseMapBase : public DebugEpochBase {
     const size_t NumBuckets = getNumBuckets();
     if constexpr (std::is_trivially_copyable_v<KeyT> &&
                   std::is_trivially_copyable_v<ValueT>) {
-      memcpy(reinterpret_cast<void *>(Buckets), OtherBuckets,
+      memcpy(reinterpret_cast<void *>(Buckets),
+             reinterpret_cast<const void *>(OtherBuckets),
              NumBuckets * sizeof(BucketT));
     } else {
       const KeyT EmptyKey = getEmptyKey();

llvm/include/llvm/ADT/Hashing.h

@@ -508,7 +508,7 @@ struct hash_combine_recursive_helper {
       // with the variadic combine because that formation can have varying
       // argument types.
       size_t partial_store_size = buffer_end - buffer_ptr;
-      memcpy(buffer_ptr, &data, partial_store_size);
+      memcpy(buffer_ptr, reinterpret_cast<void *>(&data), partial_store_size);
 
       // If the store fails, our buffer is full and ready to hash. We have to
       // either initialize the hash state (on the first full buffer) or mix

llvm/include/llvm/ADT/SmallVector.h

@@ -509,15 +509,15 @@ class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
   /// starting with "Dest", constructing elements into it as needed.
   template <typename T1, typename T2>
   static void uninitialized_copy(
-      T1 *I, T1 *E, T2 *Dest,
-      std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
-          nullptr) {
+      const T1 *I, const T1 *E, T2 *Dest,
+      std::enable_if_t<std::is_same<T1, T2>::value> * = nullptr) {
     // Use memcpy for PODs iterated by pointers (which includes SmallVector
     // iterators): std::uninitialized_copy optimizes to memmove, but we can
     // use memcpy here. Note that I and E are iterators and thus might be
     // invalid for memcpy if they are equal.
     if (I != E)
-      memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
+      memcpy(reinterpret_cast<void *>(Dest), reinterpret_cast<const void *>(I),
+             (E - I) * sizeof(T));
   }
 
   /// Double the size of the allocated memory, guaranteeing space for at
@@ -560,7 +560,8 @@ class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
 public:
   void push_back(ValueParamT Elt) {
     const T *EltPtr = reserveForParamAndGetAddress(Elt);
-    memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
+    memcpy(reinterpret_cast<void *>(this->end()),
+           reinterpret_cast<const void *>(EltPtr), sizeof(T));
     this->set_size(this->size() + 1);
   }