Make bit_cast fail if the source or dest are not trivially copyable

base/bit_cast.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_BIT_CAST_H_
 #define BASE_BIT_CAST_H_
 
 #include <string.h>
 #include <type_traits>
 
@@ skipping 45 matching lines @@
 //
 // Fortunately memcpy() is very fast.  In optimized mode, compilers replace
 // calls to memcpy() with inline object code when the size argument is a
 // compile-time constant.  On a 32-bit system, memcpy(d,s,4) compiles to one
 // load and one store, and memcpy(d,s,8) compiles to two loads and two stores.
 
 template <class Dest, class Source>
 inline Dest bit_cast(const Source& source) {
   static_assert(sizeof(Dest) == sizeof(Source),
                 "bit_cast requires source and destination to be the same size");
+  static_assert(std::is_trivially_copyable<Dest>::value,
+                "bit_cast requires the destination type to be copyable");
+  static_assert(std::is_trivially_copyable<Source>::value,
+                "bit_cast requires the source type to be copyable");
 
 #if (__GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1) || \
      (defined(__clang__) && defined(_LIBCPP_VERSION)))
   // GCC 5.1 contains the first libstdc++ with is_trivially_copyable.
   // Assume libc++ Just Works: is_trivially_copyable added on May 13th 2011.
   // However, with libc++ when GCC is the compiler the trait is buggy, see
   // crbug.com/607158, so fall back to the less strict variant for non-clang.
   static_assert(std::is_trivially_copyable<Dest>::value,

[danakj, 2016/12/20 16:40:49]

Wait we already have this. With crazy stuff for various libary versions /o\

                 "non-trivially-copyable bit_cast is undefined");
   static_assert(std::is_trivially_copyable<Source>::value,
                 "non-trivially-copyable bit_cast is undefined");
 #elif HAS_FEATURE(is_trivially_copyable)
   // The compiler supports an equivalent intrinsic.
   static_assert(__is_trivially_copyable(Dest),
                 "non-trivially-copyable bit_cast is undefined");
   static_assert(__is_trivially_copyable(Source),
                 "non-trivially-copyable bit_cast is undefined");
 #elif COMPILER_GCC
   // Fallback to compiler intrinsic on GCC and clang (which pretends to be
   // GCC). This isn't quite the same as is_trivially_copyable but it'll do for
   // our purpose.
   static_assert(__has_trivial_copy(Dest),
                 "non-trivially-copyable bit_cast is undefined");
   static_assert(__has_trivial_copy(Source),
                 "non-trivially-copyable bit_cast is undefined");
 #else
   // Do nothing, let the bots handle it.
 #endif
 
   Dest dest;
   memcpy(&dest, &source, sizeof(dest));
   return dest;
 }
 
 #endif  // BASE_BIT_CAST_H_