yencode 1.1.1 → 1.1.2

package/binding.gyp

@@ -1,9 +1,9 @@
 {
+  "variables": {
+    "enable_native_tuning%": 1,
+    "disable_avx256%": 0
+  },
   "target_defaults": {
-    "variables": {
-      "enable_native_tuning%": 1,
-      "disable_avx256%": 0
-    },
     "conditions": [
       ['target_arch=="ia32"', {
         "msvs_settings": {"VCCLCompilerTool": {"EnableEnhancedInstructionSet": "2"}}
@@ -41,7 +41,7 @@
       ['disable_avx256!=0', {
         "defines": ["YENC_DISABLE_AVX256=1"]
       }],
-      ['enable_native_tuning!=0', {
+      ['OS!="win" and enable_native_tuning!=0', {
         "defines": ["YENC_BUILD_NATIVE=1"]
       }]
     ],
@@ -128,7 +128,7 @@
       "target_name": "yencode_clmul",
       "type": "static_library",
       "sources": [
-        "src/crc_folding.c"
+        "src/crc_folding.cc"
       ],
       "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
       "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],

package/crcutil-1.0/code/multiword_64_64_intrinsic_i386_mmx.cc

@@ -16,7 +16,7 @@
 
 #include "generic_crc.h"
 
-#if CRCUTIL_USE_ASM && HAVE_I386 && HAVE_MMX
+#if CRCUTIL_USE_ASM && HAVE_I386 && HAVE_MMX && !defined(_MSC_VER) && !(defined(__GNUC__) && !defined(__clang__))
 
 namespace crcutil {
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yencode",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "SIMD accelerated yEnc encoder/decoder and CRC32 calculator",
   "keywords": [
     "yenc",

package/src/common.h

@@ -8,7 +8,7 @@
     defined(__LP64    ) || \
     defined(_M_X64    ) || \
     defined(_M_AMD64  ) || \
-    defined(_WIN64    )
+    (defined(_WIN64) && !defined(_M_ARM64))
 	#define PLATFORM_AMD64 1
 #endif
 #if defined(PLATFORM_AMD64) || \
@@ -18,7 +18,7 @@
     defined(__i686__  ) || \
     defined(_M_I86    ) || \
     defined(_M_IX86   ) || \
-    defined(_WIN32    )
+    (defined(_WIN32) && !defined(_M_ARM) && !defined(_M_ARM64))
 	#define PLATFORM_X86 1
 #endif
 #if defined(__aarch64__) || \
@@ -35,23 +35,25 @@
 #endif
 
 
-#if defined(__cplusplus) && __cplusplus > 201100 && !(defined(_MSC_VER) && defined(__clang__)) && !defined(__APPLE__)
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+	#include <stdlib.h> // MSVC ARM64 seems to need this
+	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = _aligned_malloc((len), align)
+	#define ALIGN_FREE _aligned_free
+#elif defined(__cplusplus) && __cplusplus >= 201100 && !(defined(_MSC_VER) && (defined(__clang__) || defined(_M_ARM64) || defined(_M_ARM))) && !defined(__APPLE__)
 	// C++11 method
 	// len needs to be a multiple of alignment, although it sometimes works if it isn't...
 	#include <cstdlib>
 	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = aligned_alloc(align, ((len) + (align)-1) & ~((align)-1))
 	#define ALIGN_FREE free
-#elif defined(_MSC_VER)
-	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = _aligned_malloc((len), align)
-	#define ALIGN_FREE _aligned_free
 #else
+	#include <stdlib.h>
 	#define ALIGN_ALLOC(buf, len, align) if(posix_memalign((void**)&(buf), align, (len))) (buf) = NULL
 	#define ALIGN_FREE free
 #endif
 
 
 // MSVC compatibility
-#if (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)
+#if ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)) && !defined(__clang__)
 	#define __SSE2__ 1
 	#define __SSSE3__ 1
 	#define __SSE4_1__ 1
@@ -85,12 +87,16 @@
 	#define __ARM_NEON 1
 #endif
 #if defined(_M_ARM)
-	/*#define __ARM_NEON 1*/
+	#define __ARM_NEON 1
 #endif
 #ifdef _MSC_VER
-#define __BYTE_ORDER__ 1234
-#define __ORDER_BIG_ENDIAN__ 4321
-#include <intrin.h>
+# ifndef __BYTE_ORDER__
+#  define __BYTE_ORDER__ 1234
+# endif
+# ifndef __ORDER_BIG_ENDIAN__
+#  define __ORDER_BIG_ENDIAN__ 4321
+# endif
+# include <intrin.h>
 #endif
 
 
@@ -137,6 +143,59 @@
 
 #ifdef __ARM_NEON
 # include <arm_neon.h>
+
+// ARM provides no standard way to inline define a vector :(
+static HEDLEY_ALWAYS_INLINE uint8x8_t vmake_u8(
+	uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h
+) {
+# if defined(_MSC_VER)
+	uint8_t t[] = {a,b,c,d,e,f,g,h};
+	return vld1_u8(t);
+# else
+	return (uint8x8_t){a,b,c,d,e,f,g,h};
+# endif
+}
+static HEDLEY_ALWAYS_INLINE uint8x16_t vmakeq_u8(
+	uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h,
+	uint8_t i, uint8_t j, uint8_t k, uint8_t l, uint8_t m, uint8_t n, uint8_t o, uint8_t p
+) {
+# if defined(_MSC_VER)
+	uint8_t t[] = {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+	return vld1q_u8(t);
+# else
+	return (uint8x16_t){a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+# endif
+}
+static HEDLEY_ALWAYS_INLINE int8x16_t vmakeq_s8(
+	int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f, int8_t g, int8_t h,
+	int8_t i, int8_t j, int8_t k, int8_t l, int8_t m, int8_t n, int8_t o, int8_t p
+) {
+# if defined(_MSC_VER)
+	int8_t t[] = {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+	return vld1q_s8(t);
+# else
+	return (int8x16_t){a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+# endif
+}
+
+# ifdef _MSC_VER
+#  define _CREATE_TUPLE(type, ...) type{{ __VA_ARGS__ }}
+# else
+#  define _CREATE_TUPLE(type, ...) (type){{ __VA_ARGS__ }}
+# endif
+static HEDLEY_ALWAYS_INLINE uint8x16x2_t vcreate2_u8(uint8x16_t a, uint8x16_t b) {
+	return _CREATE_TUPLE(uint8x16x2_t, a, b);
+}
+static HEDLEY_ALWAYS_INLINE int8x16x2_t vcreate2_s8(int8x16_t a, int8x16_t b) {
+	return _CREATE_TUPLE(int8x16x2_t, a, b);
+}
+static HEDLEY_ALWAYS_INLINE uint8x16x3_t vcreate3_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
+	return _CREATE_TUPLE(uint8x16x3_t, a, b, c);
+}
+static HEDLEY_ALWAYS_INLINE uint8x16x4_t vcreate4_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c, uint8x16_t d) {
+	return _CREATE_TUPLE(uint8x16x4_t, a, b, c, d);
+}
+# undef _CREATE_TUPLE
 #endif
 #ifdef PLATFORM_ARM
 bool cpu_supports_neon();
@@ -220,10 +279,13 @@ int cpu_supports_isa();
 #endif
 
 // weird thing with Apple's Clang; doesn't seem to always occur, so assume that Clang >= 9 is fine: https://github.com/animetosho/node-yencode/issues/8#issuecomment-583385864
-#if defined(__clang__) && defined(__APPLE__) && __clang_major__ < 9
+// seems that Clang < 3.6 also uses the old name
+#if defined(__clang__) && ((defined(__APPLE__) && __clang_major__ < 9) || __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 6))
 # define _lzcnt_u32 __lzcnt32
 #endif
 
+
+
 #ifdef __GNUC__
 # if __GNUC__ >= 9
 #  define LIKELIHOOD(p, c) (HEDLEY_PREDICT(!!(c), 1, p))

package/src/crc.cc

@@ -1,42 +1,57 @@
-#include "common.h"
 #include "crc_common.h"
 
-
 #include "interface.h"
 crcutil_interface::CRC* crc = NULL;
 
-
-static void do_crc32_generic(const void* data, size_t length, unsigned char out[4]) {
-	crcutil_interface::UINT64 tmp = 0;
-	crc->Compute(data, length, &tmp);
-	UNPACK_4(out, tmp);
-}
-crc_func _do_crc32 = &do_crc32_generic;
-
-static void do_crc32_incremental_generic(const void* data, size_t length, unsigned char init[4]) {
-	crcutil_interface::UINT64 tmp = PACK_4(init);
+static uint32_t do_crc32_incremental_generic(const void* data, size_t length, uint32_t init) {
+	crcutil_interface::UINT64 tmp = init;
 	crc->Compute(data, length, &tmp);
-	UNPACK_4(init, tmp);
+	return (uint32_t)tmp;
 }
 crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
 
 
 
-void do_crc32_combine(unsigned char crc1[4], const unsigned char crc2[4], size_t len2) {
-	crcutil_interface::UINT64 crc1_ = PACK_4(crc1), crc2_ = PACK_4(crc2);
+uint32_t do_crc32_combine(uint32_t crc1, uint32_t crc2, size_t len2) {
+	crcutil_interface::UINT64 crc1_ = crc1, crc2_ = crc2;
 	crc->Concatenate(crc2_, 0, len2, &crc1_);
-	UNPACK_4(crc1, crc1_);
+	return (uint32_t)crc1_;
 }
 
-void do_crc32_zeros(unsigned char crc1[4], size_t len) {
-	crcutil_interface::UINT64 crc_ = PACK_4(crc1);
+uint32_t do_crc32_zeros(uint32_t crc1, size_t len) {
+	crcutil_interface::UINT64 crc_ = crc1;
 	crc->CrcOfZeroes(len, &crc_);
-	UNPACK_4(crc1, crc_);
+	return (uint32_t)crc_;
 }
 
-extern "C" void crc_clmul_set_funcs(crc_func*, crc_func*);
-void crc_arm_set_funcs(crc_func*, crc_func*);
+void crc_clmul_set_funcs(crc_func*);
+void crc_arm_set_funcs(crc_func*);
 
+#if defined(PLATFORM_ARM) && defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <Windows.h>
+#endif
+#ifdef PLATFORM_ARM
+# ifdef __ANDROID__
+#  include <cpu-features.h>
+# elif defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD__ >= 12)
+#  include <sys/auxv.h>
+#  include <asm/hwcap.h>
+# elif (defined(__FreeBSD__) && __FreeBSD__ < 12)
+#  include <sys/sysctl.h>
+#  include <asm/hwcap.h>
+# elif defined(__APPLE__)
+#  include <sys/types.h>
+#  include <sys/sysctl.h>
+# endif
+# ifdef __FreeBSD__
+static unsigned long getauxval(unsigned long cap) {
+	unsigned long ret;
+	elf_aux_info(cap, &ret, sizeof(ret));
+	return ret;
+}
+# endif
+#endif
 void crc_init() {
 	crc = crcutil_interface::CRC::Create(
 		0xEDB88320, 0, 32, true, 0, 0, 0, 0, NULL);
@@ -46,9 +61,15 @@ void crc_init() {
 	int flags[4];
 	_cpuid1(flags);
 	if((flags[2] & 0x80202) == 0x80202) // SSE4.1 + SSSE3 + CLMUL
-		crc_clmul_set_funcs(&_do_crc32, &_do_crc32_incremental);
+		crc_clmul_set_funcs(&_do_crc32_incremental);
 #endif
 #ifdef PLATFORM_ARM
+# ifdef __APPLE__
+	int supported = 0;
+	size_t len = sizeof(supported);
+	if(sysctlbyname("hw.optional.armv8_crc32", &supported, &len, NULL, 0))
+		supported = 0;
+# endif
 	if(
 # if defined(AT_HWCAP2) && defined(HWCAP2_CRC32)
 		getauxval(AT_HWCAP2) & HWCAP2_CRC32
@@ -56,14 +77,19 @@ void crc_init() {
 		getauxval(AT_HWCAP) & HWCAP_CRC32
 # elif defined(ANDROID_CPU_FAMILY_ARM) && defined(__aarch64__)
 		android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_CRC32
-	/* no 32-bit flag - presumably CRC not allowed on 32-bit CPUs on Android */
+# elif defined(ANDROID_CPU_FAMILY_ARM) /* aarch32 */
+		android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_CRC32
+# elif defined(_WIN32)
+		IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE)
+# elif defined(__APPLE__)
+		supported
 # elif defined(__ARM_FEATURE_CRC32)
 		true /* assume available if compiled as such */
 # else
 		false
 # endif
 	) {
-		crc_arm_set_funcs(&_do_crc32, &_do_crc32_incremental);
+		crc_arm_set_funcs(&_do_crc32_incremental);
 	}
 #endif
 }

package/src/crc.h

@@ -1,9 +1,23 @@
+#ifndef __YENC_CRC_H
+#define __YENC_CRC_H
 
-extern void (*_do_crc32)(const void* data, size_t length, unsigned char out[4]);
-#define do_crc32 (*_do_crc32)
-extern void (*_do_crc32_incremental)(const void* data, size_t length, unsigned char init[4]);
-#define do_crc32_incremental (*_do_crc32_incremental)
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-void do_crc32_combine(unsigned char crc1[4], const unsigned char crc2[4], size_t len2);
-void do_crc32_zeros(unsigned char crc1[4], size_t len);
+
+
+typedef uint32_t (*crc_func)(const void*, size_t, uint32_t);
+extern crc_func _do_crc32_incremental;
+#define do_crc32 (*_do_crc32_incremental)
+
+uint32_t do_crc32_combine(uint32_t crc1, const uint32_t crc2, size_t len2);
+uint32_t do_crc32_zeros(uint32_t crc1, size_t len);
 void crc_init();
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

package/src/crc_arm.cc

@@ -1,15 +1,69 @@
-#include "common.h"
 #include "crc_common.h"
 
-#if defined(__ARM_FEATURE_CRC32) || defined(_M_ARM64) /* TODO: AArch32 for MSVC? */
+#if defined(PLATFORM_ARM) && defined(_MSC_VER) && defined(__clang__) && !defined(__ARM_FEATURE_CRC32)
+// I don't think GYP provides a nice way to detect whether MSVC or clang-cl is being used, but it doesn't use clang-cl by default, so a warning here is probably sufficient
+HEDLEY_WARNING("CRC32 acceleration is not been enabled under ARM clang-cl by default; add `-march=armv8-a+crc` to additional compiler arguments to enable");
+#endif
+
+#if defined(__ARM_FEATURE_CRC32) || (defined(_M_ARM64) && !defined(__clang__)) // MSVC doesn't support CRC for ARM32
 
 /* ARMv8 accelerated CRC */
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && !defined(__clang__)
 #include <intrin.h>
 #else
 #include <arm_acle.h>
 #endif
 
+#ifdef __aarch64__
+# define WORD_T uint64_t
+# define WORDSIZE_LOG 3  // sizeof(WORD_T) == 1<<WORDSIZE_LOG
+# define CRC_WORD __crc32d
+#else
+# define WORD_T uint32_t
+# define WORDSIZE_LOG 2  // sizeof(WORD_T) == 1<<WORDSIZE_LOG
+# define CRC_WORD __crc32w
+#endif
+
+
+// exploit CPU pipelining during CRC computation; unfortunately I haven't been able to measure any benefit
+// - Neoverse N1: no noticeable difference
+// - Cortex A53: actually runs a bit slower
+//#define ENABLE_PIPELINE_OPT 1
+
+#ifdef ENABLE_PIPELINE_OPT
+// workaround MSVC complaining "unary minus operator applied to unsigned type, result still unsigned"
+#define NEGATE(n) (uint32_t)(-((int32_t)(n)))
+
+static HEDLEY_ALWAYS_INLINE uint32_t crc_multiply(uint32_t a, uint32_t b) {
+	uint32_t res = 0;
+	for(int i=0; i<31; i++) {
+		res ^= NEGATE(b>>31) & a;
+		a = ((a >> 1) ^ (0xEDB88320 & NEGATE(a&1)));
+		b <<= 1;
+	}
+	res ^= NEGATE(b>>31) & a;
+	return res;
+}
+
+static const uint32_t crc_power[] = { // pre-computed 2^n, with first 3 entries removed (saves a shift)
+	0x00800000, 0x00008000, 0xedb88320, 0xb1e6b092, 0xa06a2517, 0xed627dae, 0x88d14467, 0xd7bbfe6a,
+	0xec447f11, 0x8e7ea170, 0x6427800e, 0x4d47bae0, 0x09fe548f, 0x83852d0f, 0x30362f1a, 0x7b5a9cc3,
+	0x31fec169, 0x9fec022a, 0x6c8dedc4, 0x15d6874d, 0x5fde7a4e, 0xbad90e37, 0x2e4e5eef, 0x4eaba214,
+	0xa8a472c0, 0x429a969e, 0x148d302a, 0xc40ba6d0, 0xc4e22c3c, 0x40000000, 0x20000000, 0x08000000
+};
+/* above table can be computed with
+	int main(void) {
+		uint32_t k = 0x80000000 >> 1;
+		for (size_t i = 0; i < 32+3; ++i) {
+			if(i>2) printf("0x%08x, ", k);
+			k = crc_multiply(k, k);
+		}
+		return 0;
+	}
+*/
+#endif
+
+
 // inspired/stolen off https://github.com/jocover/crc32_armv8/blob/master/crc32_armv8.c
 static uint32_t arm_crc_calc(uint32_t crc, const unsigned char *src, long len) {
 	
@@ -25,25 +79,74 @@ static uint32_t arm_crc_calc(uint32_t crc, const unsigned char *src, long len) {
 			src += sizeof(uint16_t);
 			len -= sizeof(uint16_t);
 		}
-		
 #ifdef __aarch64__
 		if ((uintptr_t)src & sizeof(uint32_t)) {
 			crc = __crc32w(crc, *((uint32_t *)src));
 			src += sizeof(uint32_t);
 			len -= sizeof(uint32_t);
 		}
+#endif
 	}
-	while ((len -= sizeof(uint64_t)) >= 0) {
-		crc = __crc32d(crc, *((uint64_t *)src));
-		src += sizeof(uint64_t);
+	
+	const WORD_T* srcW = (const WORD_T*)src;
+	
+#ifdef ENABLE_PIPELINE_OPT
+	// uses ideas from https://github.com/komrad36/crc#option-13-golden
+	// (this is a slightly less efficient, but much simpler implementation of the idea)
+	const unsigned SPLIT_WORDS_LOG = 10;  // make sure it's at least 2
+	const unsigned SPLIT_WORDS = 1<<SPLIT_WORDS_LOG;
+	while(len >= (long)(sizeof(WORD_T)*SPLIT_WORDS*2)) {
+		// compute 2x CRCs concurrently to leverage piplining
+		uint32_t crc2 = 0;
+		for(unsigned i=0; i<SPLIT_WORDS; i+=4) {
+			crc = CRC_WORD(crc, *srcW);
+			crc2 = CRC_WORD(crc2, *(srcW + SPLIT_WORDS));
+			srcW++;
+			crc = CRC_WORD(crc, *srcW);
+			crc2 = CRC_WORD(crc2, *(srcW + SPLIT_WORDS));
+			srcW++;
+			crc = CRC_WORD(crc, *srcW);
+			crc2 = CRC_WORD(crc2, *(srcW + SPLIT_WORDS));
+			srcW++;
+			crc = CRC_WORD(crc, *srcW);
+			crc2 = CRC_WORD(crc2, *(srcW + SPLIT_WORDS));
+			srcW++;
+		}
+		// merge the CRCs
+		// since we're multiplying by a fixed number, it could be sped up with some lookup tables
+		crc = crc_multiply(crc, crc_power[SPLIT_WORDS_LOG + WORDSIZE_LOG]) ^ crc2;
+		srcW += SPLIT_WORDS;
+		len -= sizeof(WORD_T)*SPLIT_WORDS*2;
 	}
-	if (len & sizeof(uint32_t)) {
-		crc = __crc32w(crc, *((uint32_t *)src));
-		src += sizeof(uint32_t);
+#endif
+	
+	while ((len -= sizeof(WORD_T)*8) >= 0) {
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
 	}
-#else
+	if (len & sizeof(WORD_T)*4) {
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
+	}
+	if (len & sizeof(WORD_T)*2) {
+		crc = CRC_WORD(crc, *(srcW++));
+		crc = CRC_WORD(crc, *(srcW++));
 	}
-	while ((len -= sizeof(uint32_t)) >= 0) {
+	if (len & sizeof(WORD_T)) {
+		crc = CRC_WORD(crc, *(srcW++));
+	}
+	src = (const unsigned char*)srcW;
+	
+#ifdef __aarch64__
+	if (len & sizeof(uint32_t)) {
 		crc = __crc32w(crc, *((uint32_t *)src));
 		src += sizeof(uint32_t);
 	}
@@ -58,20 +161,15 @@ static uint32_t arm_crc_calc(uint32_t crc, const unsigned char *src, long len) {
 	return crc;
 }
 
-static void do_crc32_arm(const void* data, size_t length, unsigned char out[4]) {
-	uint32_t crc = arm_crc_calc(~0, (const unsigned char*)data, (long)length);
-	UNPACK_4(out, ~crc);
-}
-static void do_crc32_incremental_arm(const void* data, size_t length, unsigned char init[4]) {
-	uint32_t crc = PACK_4(init);
-	crc = arm_crc_calc(~crc, (const unsigned char*)data, (long)length);
-	UNPACK_4(init, ~crc);
+static uint32_t do_crc32_incremental_arm(const void* data, size_t length, uint32_t init) {
+	return ~arm_crc_calc(~init, (const unsigned char*)data, (long)length);
 }
 
-void crc_arm_set_funcs(crc_func* _do_crc32, crc_func* _do_crc32_incremental) {
-	*_do_crc32 = &do_crc32_arm;
+void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
 	*_do_crc32_incremental = &do_crc32_incremental_arm;
 }
 #else
-void crc_arm_set_funcs(crc_func* _do_crc32, crc_func* _do_crc32_incremental) {}
+void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
+	(void)_do_crc32_incremental;
+}
 #endif

package/src/crc_common.h

@@ -1,11 +1,4 @@
-
-#define PACK_4(arr) (((uint_fast32_t)arr[0] << 24) | ((uint_fast32_t)arr[1] << 16) | ((uint_fast32_t)arr[2] << 8) | (uint_fast32_t)arr[3])
-#define UNPACK_4(arr, val) { \
-	arr[0] = (unsigned char)(val >> 24) & 0xFF; \
-	arr[1] = (unsigned char)(val >> 16) & 0xFF; \
-	arr[2] = (unsigned char)(val >>  8) & 0xFF; \
-	arr[3] = (unsigned char)val & 0xFF; \
-}
-
+#include "common.h"
 #include <stddef.h> // for size_t
-typedef void (*crc_func)(const void*, size_t, unsigned char[4]);
+#include "crc.h"
+