[Support/BLAKE3] LLVM-specific changes over the original BLAKE3 C implementation

Changes from original BLAKE3 sources:

* `blake.h`:
    * Changes to avoid conflicts if a client also links with its own BLAKE3 version:
        * Renamed the header macro guard with `LLVM_C_` prefix
        * Renamed the C symbols to add the `llvm_` prefix
    * Added a top header comment that references the CC0 license and points to the `LICENSE` file in the repo.
* `blake3_impl.h`: Added `#define`s to remove some of `llvm_` prefixes for the rest of the internal implementation.
* Implementation files:
    * Added a top header comment for `blake.c`
    * Used `llvm_` prefix for the C public API functions
    * Used `LLVM_LIBRARY_VISIBILITY` for internal implementation functions
    * Added `.private_extern`/`.hidden` in assembly files to reduce visibility of the internal implementation functions
* `README.md`:
    * added a note about where the sources originated from
    * Used the C++ BLAKE3 class and `llvm_` prefixed C API in place of examples and API documentation.
    * Removed instructions about how to build the files.

Author: akyrtzi

llvm/include/llvm-c/blake3.h

@@ -1,5 +1,21 @@
-#ifndef BLAKE3_H
-#define BLAKE3_H
+/*===-- llvm-c/blake3.h - BLAKE3 C Interface ----------------------*- C -*-===*\
+|*                                                                            *|
+|* Released into the public domain with CC0 1.0                               *|
+|* See 'llvm/lib/Support/BLAKE3/LICENSE' for info.                            *|
+|* SPDX-License-Identifier: CC0-1.0                                           *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to LLVM's BLAKE3 implementation.      *|
+|* Original BLAKE3 C API: https://github.com/BLAKE3-team/BLAKE3/tree/1.3.1/c  *|
+|*                                                                            *|
+|* Symbols are prefixed with 'llvm' to avoid a potential conflict with        *|
+|* another BLAKE3 version within the same program.                            *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_BLAKE3_H
+#define LLVM_C_BLAKE3_H
 
 #include <stddef.h>
 #include <stdint.h>
@@ -8,53 +24,56 @@
 extern "C" {
 #endif
 
-#define BLAKE3_VERSION_STRING "1.3.1"
-#define BLAKE3_KEY_LEN 32
-#define BLAKE3_OUT_LEN 32
-#define BLAKE3_BLOCK_LEN 64
-#define BLAKE3_CHUNK_LEN 1024
-#define BLAKE3_MAX_DEPTH 54
+#define LLVM_BLAKE3_VERSION_STRING "1.3.1"
+#define LLVM_BLAKE3_KEY_LEN 32
+#define LLVM_BLAKE3_OUT_LEN 32
+#define LLVM_BLAKE3_BLOCK_LEN 64
+#define LLVM_BLAKE3_CHUNK_LEN 1024
+#define LLVM_BLAKE3_MAX_DEPTH 54
 
 // This struct is a private implementation detail. It has to be here because
-// it's part of blake3_hasher below.
+// it's part of llvm_blake3_hasher below.
 typedef struct {
   uint32_t cv[8];
   uint64_t chunk_counter;
-  uint8_t buf[BLAKE3_BLOCK_LEN];
+  uint8_t buf[LLVM_BLAKE3_BLOCK_LEN];
   uint8_t buf_len;
   uint8_t blocks_compressed;
   uint8_t flags;
-} blake3_chunk_state;
+} llvm_blake3_chunk_state;
 
 typedef struct {
   uint32_t key[8];
-  blake3_chunk_state chunk;
+  llvm_blake3_chunk_state chunk;
   uint8_t cv_stack_len;
   // The stack size is MAX_DEPTH + 1 because we do lazy merging. For example,
   // with 7 chunks, we have 3 entries in the stack. Adding an 8th chunk
   // requires a 4th entry, rather than merging everything down to 1, because we
   // don't know whether more input is coming. This is different from how the
   // reference implementation does things.
-  uint8_t cv_stack[(BLAKE3_MAX_DEPTH + 1) * BLAKE3_OUT_LEN];
-} blake3_hasher;
-
-const char *blake3_version(void);
-void blake3_hasher_init(blake3_hasher *self);
-void blake3_hasher_init_keyed(blake3_hasher *self,
-                              const uint8_t key[BLAKE3_KEY_LEN]);
-void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context);
-void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                       size_t context_len);
-void blake3_hasher_update(blake3_hasher *self, const void *input,
-                          size_t input_len);
-void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                            size_t out_len);
-void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                 uint8_t *out, size_t out_len);
-void blake3_hasher_reset(blake3_hasher *self);
+  uint8_t cv_stack[(LLVM_BLAKE3_MAX_DEPTH + 1) * LLVM_BLAKE3_OUT_LEN];
+} llvm_blake3_hasher;
+
+const char *llvm_blake3_version(void);
+void llvm_blake3_hasher_init(llvm_blake3_hasher *self);
+void llvm_blake3_hasher_init_keyed(llvm_blake3_hasher *self,
+                                   const uint8_t key[LLVM_BLAKE3_KEY_LEN]);
+void llvm_blake3_hasher_init_derive_key(llvm_blake3_hasher *self,
+                                        const char *context);
+void llvm_blake3_hasher_init_derive_key_raw(llvm_blake3_hasher *self,
+                                            const void *context,
+                                            size_t context_len);
+void llvm_blake3_hasher_update(llvm_blake3_hasher *self, const void *input,
+                               size_t input_len);
+void llvm_blake3_hasher_finalize(const llvm_blake3_hasher *self, uint8_t *out,
+                                 size_t out_len);
+void llvm_blake3_hasher_finalize_seek(const llvm_blake3_hasher *self,
+                                      uint64_t seek, uint8_t *out,
+                                      size_t out_len);
+void llvm_blake3_hasher_reset(llvm_blake3_hasher *self);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* BLAKE3_H */
+#endif /* LLVM_C_BLAKE3_H */

llvm/include/llvm/Support/BLAKE3.h

@@ -19,7 +19,7 @@
 
 namespace llvm {
 
-/// The constant \p BLAKE3_OUT_LEN provides the default output length,
+/// The constant \p LLVM_BLAKE3_OUT_LEN provides the default output length,
 /// 32 bytes, which is recommended for most callers.
 ///
 /// Outputs shorter than the default length of 32 bytes (256 bits) provide
@@ -31,7 +31,7 @@ namespace llvm {
 /// Shorter BLAKE3 outputs are prefixes of longer ones. Explicitly
 /// requesting a short output is equivalent to truncating the default-length
 /// output.
-template <size_t NumBytes = BLAKE3_OUT_LEN>
+template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
 using BLAKE3Result = std::array<uint8_t, NumBytes>;
 
 /// A class that wrap the BLAKE3 algorithm.
@@ -40,45 +40,46 @@ class BLAKE3 {
   BLAKE3() { init(); }
 
   /// Reinitialize the internal state
-  void init() { blake3_hasher_init(&Hasher); }
+  void init() { llvm_blake3_hasher_init(&Hasher); }
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data) {
-    blake3_hasher_update(&Hasher, Data.data(), Data.size());
+    llvm_blake3_hasher_update(&Hasher, Data.data(), Data.size());
   }
 
   /// Digest more data.
   void update(StringRef Str) {
-    blake3_hasher_update(&Hasher, Str.data(), Str.size());
+    llvm_blake3_hasher_update(&Hasher, Str.data(), Str.size());
   }
 
   /// Finalize the hasher and put the result in \p Result.
   /// This doesn't modify the hasher itself, and it's possible to finalize again
   /// after adding more input.
-  template <size_t NumBytes = BLAKE3_OUT_LEN>
+  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
   void final(BLAKE3Result<NumBytes> &Result) {
-    blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
+    llvm_blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
   }
 
   /// Finalize the hasher and return an output of any length, given in bytes.
   /// This doesn't modify the hasher itself, and it's possible to finalize again
   /// after adding more input.
-  template <size_t NumBytes = BLAKE3_OUT_LEN> BLAKE3Result<NumBytes> final() {
+  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
+  BLAKE3Result<NumBytes> final() {
     BLAKE3Result<NumBytes> Result;
-    blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
+    llvm_blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
     return Result;
   }
 
   /// Returns a BLAKE3 hash for the given data.
-  template <size_t NumBytes = BLAKE3_OUT_LEN>
+  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
   static BLAKE3Result<NumBytes> hash(ArrayRef<uint8_t> Data) {
     BLAKE3 Hasher;
     Hasher.update(Data);
     return Hasher.final<NumBytes>();
   }
 
 private:
-  blake3_hasher Hasher;
+  llvm_blake3_hasher Hasher;
 };
 
 } // namespace llvm

llvm/lib/Support/BLAKE3/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(LLVM_BLAKE3_FILES
-  BLAKE3/blake3.c
-  BLAKE3/blake3_dispatch.c
-  BLAKE3/blake3_portable.c
+  blake3.c
+  blake3_dispatch.c
+  blake3_portable.c
 )
 
 # The BLAKE3 team recommends using the assembly versions, from the README:
@@ -11,38 +11,46 @@ set(LLVM_BLAKE3_FILES
 # version using C intrinsics. The assembly versions are generally
 # preferred. They perform better, they perform more consistently across
 # different compilers, and they build more quickly."
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")
+
+if (MSVC)
+  check_symbol_exists(_M_X64 "" IS_X64)
+  check_symbol_exists(_M_ARM64 "" IS_ARM64)
+else()
+  check_symbol_exists(__x86_64__ "" IS_X64)
+  check_symbol_exists(__aarch64__ "" IS_ARM64)
+endif()
+
+if (IS_X64)
   if (MSVC)
+    enable_language(ASM_MASM)
     list(APPEND LLVM_BLAKE3_FILES
-      BLAKE3/blake3_sse2_x86-64_windows_msvc.asm
-      BLAKE3/blake3_sse41_x86-64_windows_msvc.asm
-      BLAKE3/blake3_avx2_x86-64_windows_msvc.asm
-      BLAKE3/blake3_avx512_x86-64_windows_msvc.asm
+      blake3_sse2_x86-64_windows_msvc.asm
+      blake3_sse41_x86-64_windows_msvc.asm
+      blake3_avx2_x86-64_windows_msvc.asm
+      blake3_avx512_x86-64_windows_msvc.asm
     )
   elseif(WIN32)
     list(APPEND LLVM_BLAKE3_FILES
-      BLAKE3/blake3_sse2_x86-64_windows_gnu.S
-      BLAKE3/blake3_sse41_x86-64_windows_gnu.S
-      BLAKE3/blake3_avx2_x86-64_windows_gnu.S
-      BLAKE3/blake3_avx512_x86-64_windows_gnu.S
+      blake3_sse2_x86-64_windows_gnu.S
+      blake3_sse41_x86-64_windows_gnu.S
+      blake3_avx2_x86-64_windows_gnu.S
+      blake3_avx512_x86-64_windows_gnu.S
     )
   else()
     list(APPEND LLVM_BLAKE3_FILES
-      BLAKE3/blake3_sse2_x86-64_unix.S
-      BLAKE3/blake3_sse41_x86-64_unix.S
-      BLAKE3/blake3_avx2_x86-64_unix.S
-      BLAKE3/blake3_avx512_x86-64_unix.S
+      blake3_sse2_x86-64_unix.S
+      blake3_sse41_x86-64_unix.S
+      blake3_avx2_x86-64_unix.S
+      blake3_avx512_x86-64_unix.S
     )
   endif()
 endif()
 
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
+if (IS_ARM64)
   list(APPEND LLVM_BLAKE3_FILES
-    BLAKE3/blake3_neon.c
+    blake3_neon.c
   )
 endif()
 
-set(LLVM_BLAKE3_FILES
-  ${LLVM_BLAKE3_FILES}
-  PARENT_SCOPE
-)
+add_library(LLVMSupportBlake3 OBJECT EXCLUDE_FROM_ALL ${LLVM_BLAKE3_FILES})
+llvm_update_compile_flags(LLVMSupportBlake3)