Function handmade_aligned_realloc

include/Eigen/src/Core/util/Memory.h:174–194

\internal * \brief Reallocates aligned memory. * Since we know that our handmade version is based on std::malloc * we can use std::realloc to implement efficient reallocation. */

 * we can use std::realloc to implement efficient reallocation.
 */
EIGEN_DEVICE_FUNC inline void* handmade_aligned_realloc(void* ptr, std::size_t new_size, std::size_t old_size,
                                                        std::size_t alignment = EIGEN_DEFAULT_ALIGN_BYTES) {
  if (ptr == nullptr) return handmade_aligned_malloc(new_size, alignment);
  uint8_t old_offset = *(static_cast<uint8_t*>(ptr) - 1);
  void* old_original = static_cast<uint8_t*>(ptr) - old_offset;

  check_that_malloc_is_allowed();
  EIGEN_USING_STD(realloc)
  void* original = realloc(old_original, new_size + alignment);
  if (original == nullptr) return nullptr;
  if (original == old_original) return ptr;
  uint8_t offset = static_cast<uint8_t>(alignment - (reinterpret_cast<std::size_t>(original) & (alignment - 1)));
  void* aligned = static_cast<void*>(static_cast<uint8_t*>(original) + offset);
  if (offset != old_offset) {
    const void* src = static_cast<const void*>(static_cast<uint8_t*>(original) + old_offset);
    std::size_t count = (std::min)(new_size, old_size);
    std::memmove(aligned, src, count);
  }
  *(static_cast<uint8_t*>(aligned) - 1) = offset;
  return aligned;
}

/** \internal Allocates \a size bytes. The returned pointer is guaranteed to have 16 or 32 bytes alignment depending on
 * the requirements. On allocation error, the returned pointer is null, and std::bad_alloc is thrown.