@img/sharp-libvips-dev 1.0.1 → 1.0.2

package/include/glib-2.0/glib/gthread.h

@@ -139,6 +139,10 @@ struct _GOnce
 #  define G_TRYLOCK(name) g_mutex_trylock (&G_LOCK_NAME (name))
 #endif /* !G_DEBUG_LOCKS */
 
+#ifdef g_autoptr
+#define G_AUTO_LOCK(name) G_MUTEX_AUTO_LOCK (&G_LOCK_NAME (name), g__##name##_locker)
+#endif /* g_autoptr */
+
 GLIB_AVAILABLE_IN_2_32
 GThread *       g_thread_ref                    (GThread        *thread);
 GLIB_AVAILABLE_IN_2_32
@@ -339,7 +343,7 @@ typedef void GMutexLocker;
  *
  *   // Code with mutex locked here
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -350,6 +354,10 @@ typedef void GMutexLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.MUTEX_AUTO_LOCK].
+ *
  * Returns: a #GMutexLocker
  * Since: 2.44
  */
@@ -378,6 +386,49 @@ g_mutex_locker_free (GMutexLocker *locker)
   g_mutex_unlock ((GMutex *) locker);
 }
 
+/**
+ * G_MUTEX_AUTO_LOCK:
+ * @mutex: a [type@GLib.Mutex]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.MutexLocker] variable with `g_autoptr()` and lock the
+ * mutex. The mutex will be unlocked automatically when leaving the scope. The
+ * variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it is
+ * not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_MUTEX_AUTO_LOCK (&obj->mutex, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_mutex_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_MUTEX_AUTO_LOCK(mutex, var)                   \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GMutexLocker) \
+  G_GNUC_UNUSED var = g_mutex_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRecMutexLocker:
  *
@@ -414,7 +465,7 @@ typedef void GRecMutexLocker;
  *
  *   // Code with rec_mutex locked here
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -425,6 +476,10 @@ typedef void GRecMutexLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.REC_MUTEX_AUTO_LOCK].
+ *
  * Returns: a #GRecMutexLocker
  * Since: 2.60
  */
@@ -457,6 +512,49 @@ g_rec_mutex_locker_free (GRecMutexLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_REC_MUTEX_AUTO_LOCK:
+ * @mutex: a [type@GLib.RecMutex]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RecMutexLocker] variable with `g_autoptr()` and lock the
+ * mutex. The mutex will be unlocked automatically when leaving the scope. The
+ * variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it is
+ * not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_REC_MUTEX_AUTO_LOCK (&obj->rec_mutex, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rec_mutex_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_REC_MUTEX_AUTO_LOCK(mutex, var)                  \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRecMutexLocker) \
+  G_GNUC_UNUSED var = g_rec_mutex_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRWLockWriterLocker:
  *
@@ -520,7 +618,7 @@ typedef void GRWLockWriterLocker;
  *   if (self->array == NULL)
  *     self->array = g_ptr_array_new ();
  *
- *   if (cond)
+ *   if (condition)
  *     // No need to unlock
  *     return;
  *
@@ -535,6 +633,10 @@ typedef void GRWLockWriterLocker;
  * }
  * ]|
  *
+ * Note that it is common for the declared variable to not be used in the scope,
+ * which causes some compilers to warn. That can be avoided by using
+ * `G_GNUC_UNUSED` or, since 2.80, [func@GLib.RW_LOCK_WRITER_AUTO_LOCK].
+ *
  * Returns: a #GRWLockWriterLocker
  * Since: 2.62
  */
@@ -568,6 +670,49 @@ g_rw_lock_writer_locker_free (GRWLockWriterLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_RW_LOCK_WRITER_AUTO_LOCK:
+ * @mutex: a [type@GLib.RWLock]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RWLockWriterLocker] variable with `g_autoptr()` and lock
+ * for writing. The mutex will be unlocked automatically when leaving the scope.
+ * The variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it
+ * is not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_RW_LOCK_WRITER_AUTO_LOCK (&obj->rw_lock, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rw_lock_writer_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_RW_LOCK_WRITER_AUTO_LOCK(mutex, var)                 \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRWLockWriterLocker) \
+  G_GNUC_UNUSED var = g_rw_lock_writer_locker_new (mutex)
+#endif /* g_autoptr */
+
 /**
  * GRWLockReaderLocker:
  *
@@ -623,6 +768,49 @@ g_rw_lock_reader_locker_free (GRWLockReaderLocker *locker)
 }
 G_GNUC_END_IGNORE_DEPRECATIONS
 
+/**
+ * G_RW_LOCK_READER_AUTO_LOCK:
+ * @mutex: a [type@GLib.RWLock]
+ * @var: a variable name to be declared
+ *
+ * Declare a [type@GLib.RWLockReaderLocker] variable with `g_autoptr()` and lock
+ * for reading. The mutex will be unlocked automatically when leaving the scope.
+ * The variable is declared with `G_GNUC_UNUSED` to avoid compiler warning if it
+ * is not used in the scope.
+ *
+ * This feature is only supported on GCC and clang. This macro is not defined on
+ * other compilers and should not be used in programs that are intended to be
+ * portable to those compilers.
+ *
+ * Note that this should be used in a place where it is allowed to declare a
+ * variable, which could be before any statement in the case
+ * `-Wdeclaration-after-statement` is used, or C standard prior to C99.
+ *
+ * ```c
+ * {
+ *   G_RW_LOCK_READER_AUTO_LOCK (&obj->rw_lock, locker);
+ *
+ *   obj->stuff_with_lock ();
+ *   if (condition)
+ *     {
+ *       // No need to unlock
+ *       return;
+ *     }
+ *
+ *   // Unlock before end of scope
+ *   g_clear_pointer (&locker, g_rw_lock_reader_locker_free);
+ *   obj->stuff_without_lock ();
+ * }
+ * ```
+ *
+ * Since: 2.80.0
+ */
+#ifdef g_autoptr
+#define G_RW_LOCK_READER_AUTO_LOCK(mutex, var)                 \
+  GLIB_AVAILABLE_MACRO_IN_2_80 g_autoptr (GRWLockReaderLocker) \
+  G_GNUC_UNUSED var = g_rw_lock_reader_locker_new (mutex)
+#endif /* g_autoptr */
+
 G_END_DECLS
 
 #endif /* __G_THREAD_H__ */

package/include/glib-2.0/glib-unix.h

@@ -173,7 +173,7 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 /**
  * g_unix_pipe_open:
  * @self: A pair of file descriptors
- * @flags: Flags to pass to g_unix_open_pipe(), typically `FD_CLOEXEC`
+ * @flags: Flags to pass to g_unix_open_pipe(), typically `O_CLOEXEC`
  * @error: Used to report an error on failure
  *
  * Open a pipe. This is the same as g_unix_open_pipe(), but uses the
@@ -326,6 +326,12 @@ g_unix_pipe_clear (GUnixPipe *self)
 
 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (GUnixPipe, g_unix_pipe_clear)
 
+GLIB_AVAILABLE_IN_2_80
+int g_closefrom (int lowfd);
+
+GLIB_AVAILABLE_IN_2_80
+int g_fdwalk_set_cloexec (int lowfd);
+
 G_GNUC_END_IGNORE_DEPRECATIONS
 
 G_END_DECLS

package/include/glib-2.0/gobject/genums.h

@@ -320,14 +320,14 @@ void	g_flags_complete_type_info (GType	       g_flags_type,
 #define G_DEFINE_ENUM_TYPE(TypeName, type_name, ...) \
 GType \
 type_name ## _get_type (void) { \
-  static gsize g_define_type__static = 0; \
-  if (g_once_init_enter (&g_define_type__static)) { \
+  static _g_type_once_init_type g_define_type__static = 0; \
+  if (_g_type_once_init_enter (&g_define_type__static)) { \
     static const GEnumValue enum_values[] = { \
       __VA_ARGS__ , \
       { 0, NULL, NULL }, \
     }; \
     GType g_define_type = g_enum_register_static (g_intern_static_string (#TypeName), enum_values); \
-    g_once_init_leave (&g_define_type__static, g_define_type); \
+    _g_type_once_init_leave (&g_define_type__static, g_define_type); \
   } \
   return g_define_type__static; \
 } \
@@ -363,14 +363,14 @@ type_name ## _get_type (void) { \
 #define G_DEFINE_FLAGS_TYPE(TypeName, type_name, ...) \
 GType \
 type_name ## _get_type (void) { \
-  static gsize g_define_type__static = 0; \
-  if (g_once_init_enter (&g_define_type__static)) { \
+  static _g_type_once_init_type g_define_type__static = 0; \
+  if (_g_type_once_init_enter (&g_define_type__static)) { \
     static const GFlagsValue flags_values[] = { \
       __VA_ARGS__ , \
       { 0, NULL, NULL }, \
     }; \
     GType g_define_type = g_flags_register_static (g_intern_static_string (#TypeName), flags_values); \
-    g_once_init_leave (&g_define_type__static, g_define_type); \
+    _g_type_once_init_leave (&g_define_type__static, g_define_type); \
   } \
   return g_define_type__static; \
 } \

package/include/glib-2.0/gobject/glib-types.h

@@ -345,6 +345,15 @@ typedef gsize GType;
  */
 #define G_TYPE_DIR (g_dir_get_type ())
 
+/**
+ * G_TYPE_RAND:
+ *
+ * The #GType for a boxed type holding a #GRand.
+ *
+ * Since: 2.80
+ */
+#define G_TYPE_RAND (g_rand_get_type ())
+
 /**
  * G_TYPE_STRV_BUILDER:
  *
@@ -423,6 +432,8 @@ GType   g_hmac_get_type (void) G_GNUC_CONST;
 GOBJECT_AVAILABLE_IN_2_80
 GType   g_dir_get_type (void) G_GNUC_CONST;
 GOBJECT_AVAILABLE_IN_2_80
+GType   g_rand_get_type (void) G_GNUC_CONST;
+GOBJECT_AVAILABLE_IN_2_80
 GType   g_strv_builder_get_type (void) G_GNUC_CONST;
 
 GOBJECT_DEPRECATED_FOR('G_TYPE_VARIANT')

package/include/glib-2.0/gobject/gsignal.h

@@ -500,14 +500,18 @@ void   g_signal_chain_from_overridden_handler (gpointer           instance,
  * @c_handler: the #GCallback to connect.
  * @data: data to pass to @c_handler calls.
  * 
- * Connects a #GCallback function to a signal for a particular object.
+ * Connects a [type@GObject.Callback] function to a signal for a particular object.
  * 
- * The handler will be called synchronously, before the default handler of the signal. g_signal_emit() will not return control until all handlers are called.
+ * The handler will be called synchronously, before the default handler of the signal.
+ * [func@GObject.signal_emit] will not return control until all handlers are called.
  *
- * See [memory management of signal handlers][signals.html#Memory_management_of_signal_handlers] for
+ * See [memory management of signal handlers](signals.html#Memory_management_of_signal_handlers) for
  * details on how to handle the return value and memory management of @data.
  * 
- * Returns: the handler ID, of type #gulong (always greater than 0 for successful connections)
+ * This function cannot fail. If the given signal doesn’t exist, a critical
+ * warning is emitted.
+ *
+ * Returns: the handler ID, of type `gulong` (always greater than 0)
  */
 /* Intentionally not using G_CONNECT_DEFAULT here to avoid deprecation
  * warnings with older GLIB_VERSION_MAX_ALLOWED */
@@ -524,7 +528,10 @@ void   g_signal_chain_from_overridden_handler (gpointer           instance,
  * 
  * The handler will be called synchronously, after the default handler of the signal.
  * 
- * Returns: the handler ID, of type #gulong (always greater than 0 for successful connections)
+ * This function cannot fail. If the given signal doesn’t exist, a critical
+ * warning is emitted.
+ *
+ * Returns: the handler ID, of type `gulong` (always greater than 0)
  */
 #define g_signal_connect_after(instance, detailed_signal, c_handler, data) \
     g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, G_CONNECT_AFTER)
@@ -562,7 +569,10 @@ void   g_signal_chain_from_overridden_handler (gpointer           instance,
  *                   (GCallback) button_clicked_cb, other_widget);
  * ]|
  * 
- * Returns: the handler ID, of type #gulong (always greater than 0 for successful connections)
+ * This function cannot fail. If the given signal doesn’t exist, a critical
+ * warning is emitted.
+ *
+ * Returns: the handler ID, of type `gulong` (always greater than 0)
  */
 #define g_signal_connect_swapped(instance, detailed_signal, c_handler, data) \
     g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, G_CONNECT_SWAPPED)

package/include/hwy/aligned_allocator.h

@@ -18,17 +18,25 @@
 
 // Memory allocator with support for alignment and offsets.
 
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstring>
+#include <initializer_list>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 #include "hwy/base.h"
+#include "hwy/per_target.h"
 
 namespace hwy {
 
 // Minimum alignment of allocated memory for use in HWY_ASSUME_ALIGNED, which
-// requires a literal. This matches typical L1 cache line sizes, which prevents
-// false sharing.
-#define HWY_ALIGNMENT 64
+// requires a literal. To prevent false sharing, this should be at least the
+// L1 cache line size, usually 64 bytes. However, Intel's L2 prefetchers may
+// access pairs of lines, and POWER8 also has 128.
+#define HWY_ALIGNMENT 128
 
 // Pointers to functions equivalent to malloc/free with an opaque void* passed
 // to them.
@@ -40,7 +48,8 @@ using FreePtr = void (*)(void* opaque, void* memory);
 // the vector size. Calls `alloc` with the passed `opaque` pointer to obtain
 // memory or malloc() if it is null.
 HWY_DLLEXPORT void* AllocateAlignedBytes(size_t payload_size,
-                                         AllocPtr alloc_ptr, void* opaque_ptr);
+                                         AllocPtr alloc_ptr = nullptr,
+                                         void* opaque_ptr = nullptr);
 
 // Frees all memory. No effect if `aligned_pointer` == nullptr, otherwise it
 // must have been returned from a previous call to `AllocateAlignedBytes`.
@@ -110,8 +119,7 @@ AlignedUniquePtr<T> MakeUniqueAlignedWithAlloc(AllocPtr alloc, FreePtr free,
 // functions.
 template <typename T, typename... Args>
 AlignedUniquePtr<T> MakeUniqueAligned(Args&&... args) {
-  T* ptr = static_cast<T*>(AllocateAlignedBytes(
-      sizeof(T), /*alloc_ptr=*/nullptr, /*opaque_ptr=*/nullptr));
+  T* ptr = static_cast<T*>(AllocateAlignedBytes(sizeof(T)));
   return AlignedUniquePtr<T>(new (ptr) T(std::forward<Args>(args)...),
                              AlignedDeleter());
 }
@@ -207,5 +215,162 @@ AlignedFreeUniquePtr<T[]> AllocateAligned(const size_t items) {
   return AllocateAligned<T>(items, nullptr, nullptr, nullptr);
 }
 
+// A simple span containing data and size of data.
+template <typename T>
+class Span {
+ public:
+  Span() = default;
+  Span(T* data, size_t size) : size_(size), data_(data) {}
+  template <typename U>
+  Span(U u) : Span(u.data(), u.size()) {}
+  Span(std::initializer_list<const T> v) : Span(v.begin(), v.size()) {}
+
+  // Copies the contents of the initializer list to the span.
+  Span<T>& operator=(std::initializer_list<const T> v) {
+    HWY_DASSERT(size_ == v.size());
+    CopyBytes(v.begin(), data_, sizeof(T) * std::min(size_, v.size()));
+    return *this;
+  }
+
+  // Returns the size of the contained data.
+  size_t size() const { return size_; }
+
+  // Returns a pointer to the contained data.
+  T* data() { return data_; }
+  T* data() const { return data_; }
+
+  // Returns the element at index.
+  T& operator[](size_t index) const { return data_[index]; }
+
+  // Returns an iterator pointing to the first element of this span.
+  T* begin() { return data_; }
+
+  // Returns a const iterator pointing to the first element of this span.
+  constexpr const T* cbegin() const { return data_; }
+
+  // Returns an iterator pointing just beyond the last element at the
+  // end of this span.
+  T* end() { return data_ + size_; }
+
+  // Returns a const iterator pointing just beyond the last element at the
+  // end of this span.
+  constexpr const T* cend() const { return data_ + size_; }
+
+ private:
+  size_t size_ = 0;
+  T* data_ = nullptr;
+};
+
+// A multi dimensional array containing an aligned buffer.
+//
+// To maintain alignment, the innermost dimension will be padded to ensure all
+// innermost arrays are aligned.
+template <typename T, size_t axes>
+class AlignedNDArray {
+  static_assert(std::is_trivial<T>::value,
+                "AlignedNDArray can only contain trivial types");
+
+ public:
+  AlignedNDArray(AlignedNDArray&& other) = default;
+  AlignedNDArray& operator=(AlignedNDArray&& other) = default;
+
+  // Constructs an array of the provided shape and fills it with zeros.
+  explicit AlignedNDArray(std::array<size_t, axes> shape) : shape_(shape) {
+    sizes_ = ComputeSizes(shape_);
+    memory_shape_ = shape_;
+    // Round the innermost dimension up to the number of bytes available for
+    // SIMD operations on this architecture to make sure that each innermost
+    // array is aligned from the first element.
+    memory_shape_[axes - 1] = RoundUpTo(memory_shape_[axes - 1], VectorBytes());
+    memory_sizes_ = ComputeSizes(memory_shape_);
+    buffer_ = hwy::AllocateAligned<T>(memory_size());
+    hwy::ZeroBytes(buffer_.get(), memory_size() * sizeof(T));
+  }
+
+  // Returns a span containing the innermost array at the provided indices.
+  Span<T> operator[](std::array<const size_t, axes - 1> indices) {
+    return Span<T>(buffer_.get() + Offset(indices), sizes_[indices.size()]);
+  }
+
+  // Returns a const span containing the innermost array at the provided
+  // indices.
+  Span<const T> operator[](std::array<const size_t, axes - 1> indices) const {
+    return Span<const T>(buffer_.get() + Offset(indices),
+                         sizes_[indices.size()]);
+  }
+
+  // Returns the shape of the array, which might be smaller than the allocated
+  // buffer after padding the last axis to alignment.
+  const std::array<size_t, axes>& shape() const { return shape_; }
+
+  // Returns the shape of the allocated buffer, which might be larger than the
+  // used size of the array after padding to alignment.
+  const std::array<size_t, axes>& memory_shape() const { return memory_shape_; }
+
+  // Returns the size of the array, which might be smaller than the allocated
+  // buffer after padding the last axis to alignment.
+  size_t size() const { return sizes_[0]; }
+
+  // Returns the size of the allocated buffer, which might be larger than the
+  // used size of the array after padding to alignment.
+  size_t memory_size() const { return memory_sizes_[0]; }
+
+  // Returns a pointer to the allocated buffer.
+  T* data() { return buffer_.get(); }
+
+  // Returns a const pointer to the buffer.
+  const T* data() const { return buffer_.get(); }
+
+  // Truncates the array by updating its shape.
+  //
+  // The new shape must be equal to or less than the old shape in all axes.
+  //
+  // Doesn't modify underlying memory.
+  void truncate(const std::array<size_t, axes>& new_shape) {
+#if HWY_IS_DEBUG_BUILD
+    for (size_t axis_index = 0; axis_index < axes; ++axis_index) {
+      HWY_ASSERT(new_shape[axis_index] <= shape_[axis_index]);
+    }
+#endif
+    shape_ = new_shape;
+    sizes_ = ComputeSizes(shape_);
+  }
+
+ private:
+  std::array<size_t, axes> shape_;
+  std::array<size_t, axes> memory_shape_;
+  std::array<size_t, axes + 1> sizes_;
+  std::array<size_t, axes + 1> memory_sizes_;
+  hwy::AlignedFreeUniquePtr<T[]> buffer_;
+
+  // Computes offset in the buffer based on the provided indices.
+  size_t Offset(std::array<const size_t, axes - 1> indices) const {
+    size_t offset = 0;
+    size_t shape_index = 0;
+    for (const size_t axis_index : indices) {
+      offset += memory_sizes_[shape_index + 1] * axis_index;
+      shape_index++;
+    }
+    return offset;
+  }
+
+  // Computes the sizes of all sub arrays based on the sizes of each axis.
+  //
+  // Does this by multiplying the size of each axis with the previous one in
+  // reverse order, starting with the conceptual axis of size 1 containing the
+  // actual elements in the array.
+  static std::array<size_t, axes + 1> ComputeSizes(
+      std::array<size_t, axes> shape) {
+    std::array<size_t, axes + 1> sizes;
+    size_t axis = shape.size();
+    sizes[axis] = 1;
+    while (axis > 0) {
+      --axis;
+      sizes[axis] = sizes[axis + 1] * shape[axis];
+    }
+    return sizes;
+  }
+};
+
 }  // namespace hwy
 #endif  // HIGHWAY_HWY_ALIGNED_ALLOCATOR_H_