blake3: sync with upstream

Import AVX512 improvements and fast XOF output

Author: riptl

NOTICE

@@ -235,7 +235,7 @@ From https://cr.yp.to/chacha.html and https://datatracker.ietf.org/doc/html/rfc7
 =======================================================================
 
 The BLAKE3 implementation in src/ballet/blake3 is currently a modified
-implementation of the BLAKE3 project implementation circa 2023-May.
+implementation of the BLAKE3 project implementation circa 2025-Aug.
 From
 https://github.com/BLAKE3-team/BLAKE3/tree/master/c
 

src/ballet/blake3/blake3.c

@@ -1,5 +1,5 @@
 // Source originally from https://github.com/BLAKE3-team/BLAKE3
-// From commit: 64747d48ffe9d1fbf4b71e94cabeb8a211461081
+// From commit: df610ddc3b93841ffc59a87e3da659a15910eb46
 
 #ifndef BLAKE3_H
 #define BLAKE3_H
@@ -11,7 +11,9 @@
 extern "C" {
 #endif
 
-#define BLAKE3_VERSION_STRING "1.3.3"
+#define BLAKE3_API
+
+#define BLAKE3_VERSION_STRING "1.8.2"
 #define BLAKE3_KEY_LEN 32
 #define BLAKE3_OUT_LEN 32
 #define BLAKE3_BLOCK_LEN 64
@@ -41,20 +43,20 @@ typedef struct {
   uint8_t cv_stack[(BLAKE3_MAX_DEPTH + 1) * BLAKE3_OUT_LEN];
 } blake3_hasher;
 
-const char *fd_blake3_version(void);
-void fd_blake3_hasher_init(blake3_hasher *self);
-void fd_blake3_hasher_init_keyed(blake3_hasher *self,
-                                 const uint8_t key[BLAKE3_KEY_LEN]);
-void fd_blake3_hasher_init_derive_key(blake3_hasher *self, const char *context);
-void fd_blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                          size_t context_len);
-void fd_blake3_hasher_update(blake3_hasher *self, const void *input,
-                             size_t input_len);
-void fd_blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                               size_t out_len);
-void fd_blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                    uint8_t *out, size_t out_len);
-void fd_blake3_hasher_reset(blake3_hasher *self);
+BLAKE3_API const char *blake3_version(void);
+BLAKE3_API void blake3_hasher_init(blake3_hasher *self);
+BLAKE3_API void blake3_hasher_init_keyed(blake3_hasher *self,
+                                         const uint8_t key[BLAKE3_KEY_LEN]);
+BLAKE3_API void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context);
+BLAKE3_API void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
+                                                  size_t context_len);
+BLAKE3_API void blake3_hasher_update(blake3_hasher *self, const void *input,
+                                     size_t input_len);
+BLAKE3_API void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
+                                       size_t out_len);
+BLAKE3_API void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
+                                            uint8_t *out, size_t out_len);
+BLAKE3_API void blake3_hasher_reset(blake3_hasher *self);
 
 #ifdef __cplusplus
 }

src/ballet/blake3/blake3.h

@@ -1,6 +1,6 @@
 
 // Source originally from https://github.com/BLAKE3-team/BLAKE3
-// From commit: 64747d48ffe9d1fbf4b71e94cabeb8a211461081
+// From commit: 2dd4e57f68d85f3983b1880b66250fc7bdf0b7c8
 
 #include "blake3_impl.h"
 
@@ -171,7 +171,7 @@ INLINE void transpose_vecs(__m256i vecs[DEGREE]) {
   __m256i gh_0145 = _mm256_unpacklo_epi32(vecs[6], vecs[7]);
   __m256i gh_2367 = _mm256_unpackhi_epi32(vecs[6], vecs[7]);
 
-  // Interleave 64-bit lates. The low unpack is lanes 00/22 and the high is
+  // Interleave 64-bit lanes. The low unpack is lanes 00/22 and the high is
   // 11/33.
   __m256i abcd_04 = _mm256_unpacklo_epi64(ab_0145, cd_0145);
   __m256i abcd_15 = _mm256_unpackhi_epi64(ab_0145, cd_0145);
@@ -232,10 +232,10 @@ INLINE void load_counters(uint64_t counter, bool increment_counter,
 }
 
 static
-void fd_blake3_hash8_avx2(const uint8_t *const *inputs, size_t blocks,
-                          const uint32_t key[8], uint64_t counter,
-                          bool increment_counter, uint8_t flags,
-                          uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
+void blake3_hash8_avx2(const uint8_t *const *inputs, size_t blocks,
+                       const uint32_t key[8], uint64_t counter,
+                       bool increment_counter, uint8_t flags,
+                       uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
   __m256i h_vecs[8] = {
       set1(key[0]), set1(key[1]), set1(key[2]), set1(key[3]),
       set1(key[4]), set1(key[5]), set1(key[6]), set1(key[7]),
@@ -291,27 +291,27 @@ void fd_blake3_hash8_avx2(const uint8_t *const *inputs, size_t blocks,
 }
 
 #if FD_HAS_AVX
-void fd_blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
+void blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
+                            size_t blocks, const uint32_t key[8],
+                            uint64_t counter, bool increment_counter,
+                            uint8_t flags, uint8_t flags_start,
+                            uint8_t flags_end, uint8_t *out);
+#else
+void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
                                size_t blocks, const uint32_t key[8],
                                uint64_t counter, bool increment_counter,
                                uint8_t flags, uint8_t flags_start,
                                uint8_t flags_end, uint8_t *out);
-#else
-void fd_blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                                  size_t blocks, const uint32_t key[8],
-                                  uint64_t counter, bool increment_counter,
-                                  uint8_t flags, uint8_t flags_start,
-                                  uint8_t flags_end, uint8_t *out);
 #endif /* FD_HAS_AVX */
 
-void fd_blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
-                              size_t blocks, const uint32_t key[8],
-                              uint64_t counter, bool increment_counter,
-                              uint8_t flags, uint8_t flags_start,
-                              uint8_t flags_end, uint8_t *out) {
+void blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
+                           size_t blocks, const uint32_t key[8],
+                           uint64_t counter, bool increment_counter,
+                           uint8_t flags, uint8_t flags_start,
+                           uint8_t flags_end, uint8_t *out) {
   while (num_inputs >= DEGREE) {
-    fd_blake3_hash8_avx2(inputs, blocks, key, counter, increment_counter, flags,
-                         flags_start, flags_end, out);
+    blake3_hash8_avx2(inputs, blocks, key, counter, increment_counter, flags,
+                      flags_start, flags_end, out);
     if (increment_counter) {
       counter += DEGREE;
     }
@@ -320,11 +320,11 @@ void fd_blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
     out = &out[DEGREE * BLAKE3_OUT_LEN];
   }
 #if FD_HAS_AVX
-  fd_blake3_hash_many_sse41(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end, out);
+  blake3_hash_many_sse41(inputs, num_inputs, blocks, key, counter,
+                         increment_counter, flags, flags_start, flags_end, out);
 #else
-  fd_blake3_hash_many_portable(inputs, num_inputs, blocks, key, counter,
-                               increment_counter, flags, flags_start, flags_end,
-                               out);
+  blake3_hash_many_portable(inputs, num_inputs, blocks, key, counter,
+                            increment_counter, flags, flags_start, flags_end,
+                            out);
 #endif
 }