@img/sharp-libvips-dev-wasm32 1.0.0 → 1.0.2

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

@@ -421,9 +421,11 @@ G_BEGIN_DECLS
  * A numerical value which represents the unique identifier of a registered
  * type.
  */
-#if     GLIB_SIZEOF_SIZE_T != GLIB_SIZEOF_LONG || !defined (G_CXX_STD_VERSION)
+#if     GLIB_SIZEOF_VOID_P > GLIB_SIZEOF_SIZE_T
+typedef guintptr                        GType;
+#elif     GLIB_SIZEOF_SIZE_T != GLIB_SIZEOF_LONG || !defined (G_CXX_STD_VERSION)
 typedef gsize                           GType;
-#else   /* for historic reasons, C++ links against gulong GTypes */
+#else   /* for historic reasons, C++ on non-Morello/CHERI systems links against gulong GTypes */
 typedef gulong                          GType;
 #endif
 typedef struct _GValue                  GValue;
@@ -2009,8 +2011,8 @@ guint     g_type_get_type_registration_serial (void);
  * GType
  * gtk_gadget_get_type (void)
  * {
- *   static gsize static_g_define_type_id = 0;
- *   if (g_once_init_enter (&static_g_define_type_id))
+ *   static GType static_g_define_type_id = 0;
+ *   if (g_once_init_enter_pointer (&static_g_define_type_id))
  *     {
  *       GType g_define_type_id =
  *         g_type_register_static_simple (GTK_TYPE_WIDGET,
@@ -2030,7 +2032,7 @@ guint     g_type_get_type_registration_serial (void);
  *         };
  *         g_type_add_interface_static (g_define_type_id, TYPE_GIZMO, &g_implement_interface_info);
  *       }
- *       g_once_init_leave (&static_g_define_type_id, g_define_type_id);
+ *       g_once_init_leave_pointer (&static_g_define_type_id, g_define_type_id);
  *     }
  *   return static_g_define_type_id;
  * }
@@ -2267,6 +2269,16 @@ static void     type_name##_class_intern_init (gpointer klass, \
 }
 #endif /* GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 */
 
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_80
+#define _g_type_once_init_type GType
+#define _g_type_once_init_enter g_once_init_enter_pointer
+#define _g_type_once_init_leave g_once_init_leave_pointer
+#else  /* if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_80 */
+#define _g_type_once_init_type gsize
+#define _g_type_once_init_enter g_once_init_enter
+#define _g_type_once_init_leave g_once_init_leave
+#endif  /* GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_80 */
+
 /* Added for _G_DEFINE_TYPE_EXTENDED_WITH_PRELUDE */
 #define _G_DEFINE_TYPE_EXTENDED_BEGIN_PRE(TypeName, type_name, TYPE_PARENT) \
 \
@@ -2293,15 +2305,15 @@ type_name##_get_instance_private (TypeName *self) \
 GType \
 type_name##_get_type (void) \
 { \
-  static gsize static_g_define_type_id = 0;
+  static _g_type_once_init_type static_g_define_type_id = 0;
   /* Prelude goes here */
 
 /* Added for _G_DEFINE_TYPE_EXTENDED_WITH_PRELUDE */
 #define _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \
-  if (g_once_init_enter (&static_g_define_type_id)) \
+  if (_g_type_once_init_enter (&static_g_define_type_id)) \
     { \
       GType g_define_type_id = type_name##_get_type_once (); \
-      g_once_init_leave (&static_g_define_type_id, g_define_type_id); \
+      _g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
     }					\
   return static_g_define_type_id; \
 } /* closes type_name##_get_type() */ \
@@ -2346,8 +2358,8 @@ static void     type_name##_default_init_adapter (TypeName##Interface *klass, \
 GType \
 type_name##_get_type (void) \
 { \
-  static gsize static_g_define_type_id = 0; \
-  if (g_once_init_enter (&static_g_define_type_id)) \
+  static _g_type_once_init_type static_g_define_type_id = 0; \
+  if (_g_type_once_init_enter (&static_g_define_type_id)) \
     { \
       GType g_define_type_id = \
         g_type_register_static_simple (G_TYPE_INTERFACE, \
@@ -2363,7 +2375,7 @@ type_name##_get_type (void) \
 #define _G_DEFINE_INTERFACE_EXTENDED_END()	\
         /* following custom code */		\
       }						\
-      g_once_init_leave (&static_g_define_type_id, g_define_type_id); \
+      _g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
     }						\
   return static_g_define_type_id; \
 } /* closes type_name##_get_type() */
@@ -2472,11 +2484,11 @@ static GType type_name##_get_type_once (void); \
 GType \
 type_name##_get_type (void) \
 { \
-  static gsize static_g_define_type_id = 0; \
-  if (g_once_init_enter (&static_g_define_type_id)) \
+  static _g_type_once_init_type static_g_define_type_id = 0; \
+  if (_g_type_once_init_enter (&static_g_define_type_id)) \
     { \
       GType g_define_type_id = type_name##_get_type_once (); \
-      g_once_init_leave (&static_g_define_type_id, g_define_type_id); \
+      _g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
     } \
   return static_g_define_type_id; \
 } \
@@ -2509,11 +2521,11 @@ static GType type_name##_get_type_once (void); \
 GType \
 type_name##_get_type (void) \
 { \
-  static gsize static_g_define_type_id = 0; \
-  if (g_once_init_enter (&static_g_define_type_id)) \
+  static _g_type_once_init_type static_g_define_type_id = 0; \
+  if (_g_type_once_init_enter (&static_g_define_type_id)) \
     { \
       GType g_define_type_id = type_name##_get_type_once (); \
-      g_once_init_leave (&static_g_define_type_id, g_define_type_id); \
+      _g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
     } \
   return static_g_define_type_id; \
 } \
@@ -2562,11 +2574,11 @@ static GType type_name##_get_type_once (void); \
 GType \
 type_name##_get_type (void) \
 { \
-  static gsize static_g_define_type_id = 0; \
-  if (g_once_init_enter (&static_g_define_type_id)) \
+  static _g_type_once_init_type static_g_define_type_id = 0; \
+  if (_g_type_once_init_enter (&static_g_define_type_id)) \
     { \
       GType g_define_type_id = type_name##_get_type_once (); \
-      g_once_init_leave (&static_g_define_type_id, g_define_type_id); \
+      _g_type_once_init_leave (&static_g_define_type_id, g_define_type_id); \
     } \
   return static_g_define_type_id; \
 } \
@@ -2710,6 +2722,27 @@ const gchar *    g_type_name_from_class         (GTypeClass	*g_class);
  */
 #define	G_TYPE_FLAG_RESERVED_ID_BIT	((GType) (1 << 0))
 
+/**
+ * GPOINTER_TO_TYPE:
+ * @p: The pointer to convert to a #GType
+ *
+ * This macro should be used instead of GPOINTER_TO_SIZE() to ensure
+ * portability since #GType is not guaranteed to be the same as #gsize.
+ *
+ * Since: 2.80
+ */
+#define GPOINTER_TO_TYPE(p) ((GType) (guintptr) (p)) GOBJECT_AVAILABLE_MACRO_IN_2_80
+/**
+ * GTYPE_TO_POINTER:
+ * @t: The #GType to convert to a pointer
+ *
+ * This macro should be used instead of GSIZE_TO_POINTER() to ensure
+ * portability since #GType is not guaranteed to be the same as #gsize.
+ *
+ * Since: 2.80
+ */
+#define GTYPE_TO_POINTER(t) ((gpointer) (guintptr) (t)) GOBJECT_AVAILABLE_MACRO_IN_2_80
+
 G_END_DECLS
 
 #endif /* __G_TYPE_H__ */

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

@@ -40,13 +40,6 @@ typedef struct _GTypeModuleClass GTypeModuleClass;
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GTypeModule, g_object_unref)
 
-/**
- * GTypeModule:
- * @name: the name of the module
- * 
- * The members of the GTypeModule structure should not 
- * be accessed directly, except for the @name field.
- */
 struct _GTypeModule 
 {
   GObject parent_instance;

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

@@ -80,12 +80,6 @@ typedef void  (*GTypePluginCompleteInterfaceInfo) (GTypePlugin     *plugin,
 						   GType            instance_type,
 						   GType            interface_type,
 						   GInterfaceInfo  *info);
-/**
- * GTypePlugin:
- * 
- * The GTypePlugin typedef is used as a placeholder 
- * for objects that implement the GTypePlugin interface.
- */
 /**
  * GTypePluginClass:
  * @use_plugin: Increases the use count of the plugin.

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

@@ -41,13 +41,6 @@ G_BEGIN_DECLS
 
 /* --- typedefs & structs --- */
 typedef struct _GValueArray GValueArray;
-/**
- * GValueArray:
- * @n_values: number of values contained in the array
- * @values: array of values
- * 
- * A #GValueArray contains an array of #GValue elements.
- */
 struct _GValueArray
 {
   guint   n_values;

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

@@ -18,17 +18,7 @@
  *
  * gvaluecollector.h: GValue varargs stubs
  */
-/**
- * SECTION:value_collection
- * @Short_description: Converting varargs to generic values
- * @Title: Varargs Value Collection
- * 
- * The macros in this section provide the varargs parsing support needed
- * in variadic GObject functions such as g_object_new() or g_object_set().
- *
- * They currently support the collection of integral types, floating point 
- * types and pointers.
- */
+
 #ifndef __G_VALUE_COLLECTOR_H__
 #define __G_VALUE_COLLECTOR_H__
 

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

@@ -263,6 +263,8 @@ GOBJECT_AVAILABLE_IN_ALL
 const gchar *         g_value_get_string	(const GValue *value);
 GOBJECT_AVAILABLE_IN_ALL
 gchar*		      g_value_dup_string	(const GValue *value);
+GOBJECT_AVAILABLE_IN_2_80
+gchar*		      g_value_steal_string	(GValue *value);
 GOBJECT_AVAILABLE_IN_ALL
 void		      g_value_set_pointer	(GValue	      *value,
 						 gpointer      v_pointer);

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_