yencode 1.1.5 → 1.2.1

package/binding.gyp

@@ -1,7 +1,8 @@
 {
   "variables": {
     "enable_native_tuning%": 1,
-    "disable_avx256%": 0
+    "disable_avx256%": 0,
+    "disable_crcutil%": 0
   },
   "target_defaults": {
     "conditions": [
@@ -41,6 +42,9 @@
       ['disable_avx256!=0', {
         "defines": ["YENC_DISABLE_AVX256=1"]
       }],
+      ['disable_crcutil!=0', {
+        "defines": ["YENC_DISABLE_CRCUTIL=1"]
+      }],
       ['OS!="win" and enable_native_tuning!=0', {
         "defines": ["YENC_BUILD_NATIVE=1"]
       }],
@@ -74,7 +78,7 @@
   "targets": [
     {
       "target_name": "yencode",
-      "dependencies": ["crcutil", "yencode_sse2", "yencode_ssse3", "yencode_clmul", "yencode_clmul256", "yencode_avx", "yencode_avx2", "yencode_vbmi2", "yencode_neon", "yencode_armcrc", "yencode_rvv"],
+      "dependencies": ["yencode_sse2", "yencode_ssse3", "yencode_clmul", "yencode_clmul256", "yencode_avx", "yencode_avx2", "yencode_vbmi2", "yencode_neon", "yencode_armcrc", "yencode_pmull", "yencode_rvv", "yencode_zbkc"],
       "sources": [
         "src/yencode.cc",
         "src/platform.cc",
@@ -82,7 +86,12 @@
         "src/decoder.cc",
         "src/crc.cc"
       ],
-      "include_dirs": ["crcutil-1.0/code","crcutil-1.0/examples"]
+      "conditions": [
+        ['target_arch in "ia32 x64" and disable_crcutil==0', {
+          "dependencies": ["crcutil"],
+          "include_dirs": ["crcutil-1.0/code","crcutil-1.0/examples"]
+        }]
+      ]
     },
     {
       "target_name": "yencode_sse2",
@@ -324,7 +333,8 @@
       "target_name": "yencode_rvv",
       "type": "static_library",
       "sources": [
-        "src/encoder_rvv.cc"
+        "src/encoder_rvv.cc",
+        "src/decoder_rvv.cc"
       ],
       "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
       "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
@@ -338,9 +348,13 @@
           "variables": {"supports_rvv%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/encoder_rvv.cc -march=rv64gcv 2>/dev/null || true)"},
           "conditions": [
             ['supports_rvv!=""', {
+              "cflags!": ["-march=native"],
+              "cxxflags!": ["-march=native"],
               "cflags": ["-march=rv64gcv"],
               "cxxflags": ["-march=rv64gcv"],
               "xcode_settings": {
+                "OTHER_CFLAGS!": ["-march=native"],
+                "OTHER_CXXFLAGS!": ["-march=native"],
                 "OTHER_CFLAGS": ["-march=rv64gcv"],
                 "OTHER_CXXFLAGS": ["-march=rv64gcv"],
               }
@@ -351,9 +365,13 @@
           "variables": {"supports_rvv%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/encoder_rvv.cc -march=rv32gcv 2>/dev/null || true)"},
           "conditions": [
             ['supports_rvv!=""', {
+              "cflags!": ["-march=native"],
+              "cxxflags!": ["-march=native"],
               "cflags": ["-march=rv32gcv"],
               "cxxflags": ["-march=rv32gcv"],
               "xcode_settings": {
+                "OTHER_CFLAGS!": ["-march=native"],
+                "OTHER_CXXFLAGS!": ["-march=native"],
                 "OTHER_CFLAGS": ["-march=rv32gcv"],
                 "OTHER_CXXFLAGS": ["-march=rv32gcv"],
               }
@@ -399,8 +417,94 @@
       ]
     },
     {
-      "target_name": "crcutil",
+      "target_name": "yencode_pmull",
       "type": "static_library",
+      "sources": [
+        "src/crc_arm_pmull.cc"
+      ],
+      "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "xcode_settings": {
+        "OTHER_CFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+        "OTHER_CXXFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"]
+      },
+      "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
+      "conditions": [
+        ['target_arch in "arm arm64"', {
+          "cflags!": ["-march=native"],
+          "cxxflags!": ["-march=native"],
+          "cflags": ["-march=armv8-a+crc+crypto"],
+          "cxxflags": ["-march=armv8-a+crc+crypto"],
+          "xcode_settings": {
+            "OTHER_CFLAGS!": ["-march=native"],
+            "OTHER_CXXFLAGS!": ["-march=native"],
+            "OTHER_CFLAGS": ["-march=armv8-a+crc+crypto"],
+            "OTHER_CXXFLAGS": ["-march=armv8-a+crc+crypto"],
+          }
+        }],
+        ['OS!="win" and target_arch=="arm"', {
+          "cflags": ["-mfpu=neon","-fno-lto"],
+          "cxxflags": ["-mfpu=neon","-fno-lto"],
+          "xcode_settings": {
+            "OTHER_CFLAGS": ["-mfpu=neon","-fno-lto"],
+            "OTHER_CXXFLAGS": ["-mfpu=neon","-fno-lto"]
+          }
+        }]
+      ]
+    },
+    {
+      "target_name": "yencode_zbkc",
+      "type": "static_library",
+      "sources": [
+        "src/crc_riscv.cc"
+      ],
+      "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "xcode_settings": {
+        "OTHER_CFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+        "OTHER_CXXFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"]
+      },
+      "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
+      "conditions": [
+        ['target_arch=="riscv64" and OS!="win"', {
+          "variables": {"supports_zbkc%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/crc_riscv.cc -march=rv64gc_zbkc 2>/dev/null || true)"},
+          "conditions": [
+            ['supports_zbkc!=""', {
+              "cflags!": ["-march=native"],
+              "cxxflags!": ["-march=native"],
+              "cflags": ["-march=rv64gc_zbkc"],
+              "cxxflags": ["-march=rv64gc_zbkc"],
+              "xcode_settings": {
+                "OTHER_CFLAGS!": ["-march=native"],
+                "OTHER_CXXFLAGS!": ["-march=native"],
+                "OTHER_CFLAGS": ["-march=rv64gc_zbkc"],
+                "OTHER_CXXFLAGS": ["-march=rv64gc_zbkc"],
+              }
+            }]
+          ]
+        }],
+        ['target_arch=="riscv32" and OS!="win"', {
+          "variables": {"supports_zbkc%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/crc_riscv.cc -march=rv32gc_zbkc 2>/dev/null || true)"},
+          "conditions": [
+            ['supports_zbkc!=""', {
+              "cflags!": ["-march=native"],
+              "cxxflags!": ["-march=native"],
+              "cflags": ["-march=rv32gc_zbkc"],
+              "cxxflags": ["-march=rv32gc_zbkc"],
+              "xcode_settings": {
+                "OTHER_CFLAGS!": ["-march=native"],
+                "OTHER_CXXFLAGS!": ["-march=native"],
+                "OTHER_CFLAGS": ["-march=rv32gc_zbkc"],
+                "OTHER_CXXFLAGS": ["-march=rv32gc_zbkc"],
+              }
+            }]
+          ]
+        }]
+      ]
+    },
+    {
+      "target_name": "crcutil",
+      "type": "none",
       "sources": [
         "crcutil-1.0/code/crc32c_sse4.cc",
         "crcutil-1.0/code/multiword_64_64_cl_i386_mmx.cc",
@@ -422,7 +526,12 @@
       },
       "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
       "include_dirs": ["crcutil-1.0/code", "crcutil-1.0/tests"],
-      "defines": ["CRCUTIL_USE_MM_CRC32=0"]
+      "defines": ["CRCUTIL_USE_MM_CRC32=0"],
+      "conditions": [
+        ['target_arch in "ia32 x64" and disable_crcutil==0', {
+          "type": "static_library",
+        }]
+      ]
     }
   ]
 }

package/index.js

@@ -190,6 +190,8 @@ module.exports = {
 	crc32: y.crc32,
 	crc32_combine: y.crc32_combine,
 	crc32_zeroes: y.crc32_zeroes,
+	crc32_multiply: y.crc32_multiply,
+	crc32_shift: y.crc32_shift,
 	
 	post: function(filename, data, line_size) {
 		if(!line_size) line_size = 128;

package/package.json

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

package/src/common.h

@@ -125,7 +125,7 @@
 #ifdef __POPCNT__
 #include <nmmintrin.h>
 // POPCNT can never return a negative result, but GCC doesn't seem to realise this, so typecast it to hint it better
-#define popcnt32 (unsigned int)_mm_popcnt_u32 
+#define popcnt32 (unsigned int)_mm_popcnt_u32
 #endif
 
 #if defined(__AVX2__) || defined(__AVX512F__)
@@ -209,7 +209,9 @@ static HEDLEY_ALWAYS_INLINE uint8x16x4_t vcreate4_u8(uint8x16_t a, uint8x16_t b,
 # undef _CREATE_TUPLE
 #endif
 #ifdef PLATFORM_ARM
-bool cpu_supports_neon();
+namespace RapidYenc {
+	bool cpu_supports_neon();
+}
 #endif
 
 #ifdef _MSC_VER
@@ -240,11 +242,13 @@ enum YEncDecIsaLevel {
 enum YEncDecIsaLevel {
 	ISA_GENERIC = 0,
 	ISA_FEATURE_CRC = 8,
+	ISA_FEATURE_PMULL = 0x40,
 	ISA_LEVEL_NEON = 0x1000
 };
 #elif defined(__riscv)
 enum YEncDecIsaLevel {
 	ISA_GENERIC = 0,
+	ISA_FEATURE_ZBC = 16,
 	ISA_LEVEL_RVV = 0x10000
 };
 #else
@@ -273,7 +277,7 @@ enum YEncDecIsaLevel {
 # if defined(__POPCNT__)
 #  if defined(__LZCNT__)
 #   define ISA_NATIVE (enum YEncDecIsaLevel)(_ISA_NATIVE | ISA_FEATURE_POPCNT | ISA_FEATURE_LZCNT)
-#  else 
+#  else
 #   define ISA_NATIVE (enum YEncDecIsaLevel)(_ISA_NATIVE | ISA_FEATURE_POPCNT)
 #  endif
 # else
@@ -281,18 +285,40 @@ enum YEncDecIsaLevel {
 # endif
 #endif
 
-int cpu_supports_isa();
+namespace RapidYenc {
+	int cpu_supports_isa();
+	int cpu_supports_crc_isa();
+}
 #endif // PLATFORM_X86
 
 
 #ifdef __riscv
-bool cpu_supports_rvv();
+namespace RapidYenc {
+	bool cpu_supports_rvv();
+}
 #endif
 #if defined(__riscv_vector) && defined(HEDLEY_GCC_VERSION) && !HEDLEY_GCC_VERSION_CHECK(13,0,0)
 // GCC added RVV intrinsics in GCC13
 # undef __riscv_vector
+#elif defined(__riscv_vector) && defined(HEDLEY_GCC_VERSION) && !HEDLEY_GCC_VERSION_CHECK(14,0,0)
+// ...however, GCC13 lacks necessary mask<>vector vreinterpret casts, and it crashes on type punning, so I can't be bothered trying to make it work
+# undef __riscv_vector
+#endif
+#ifdef __riscv_vector
+# include <riscv_vector.h>
+# ifdef __riscv_v_intrinsic
+#  define RV(f) __riscv_##f
+# else
+#  define RV(f) f
+# endif
+# if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 12000
+#  define RV_MASK_CAST(masksz, vecsz, vec) RV(vreinterpret_v_u##vecsz##m1_b##masksz)(vec)
+#  define RV_VEC_U8MF4_CAST(vec) RV(vlmul_trunc_v_u8m1_u8mf4)(RV(vreinterpret_v_b4_u8m1)(vec))
+# else
+#  define RV_MASK_CAST(masksz, vecsz, vec) *(vbool##masksz##_t*)(&(vec))
+#  define RV_VEC_U8MF4_CAST(vec) *(vuint8mf4_t*)(&(vec))
+# endif
 #endif
-
 
 #include <string.h>
 #if !defined(_MSC_VER) || defined(_STDINT) || _MSC_VER >= 1900
@@ -300,7 +326,11 @@ bool cpu_supports_rvv();
 # include <stddef.h>
 #else
 /* Workaround for older MSVC not supporting stdint.h - just pull it from V8 */
-# include <v8.h>
+# if defined(NODE_GYP_MODULE_NAME) || defined(V8_DEPRECATION_WARNINGS)
+#  include <v8.h>
+# else
+#  include "stdint.h"
+# endif
 #endif
 
 

package/src/crc.cc

@@ -1,16 +1,23 @@
 #include "crc_common.h"
 
+#if defined(PLATFORM_X86) && !defined(__ILP32__) && !defined(YENC_DISABLE_CRCUTIL)
+// Use crcutil for computing CRC32 (generic implementation)
+
 #include "interface.h"
 crcutil_interface::CRC* crc = NULL;
+#define GENERIC_CRC_INIT crc = crcutil_interface::CRC::Create(0xEDB88320, 0, 32, true, 0, 0, 0, 0, NULL)
+// instance never deleted... oh well...
 
-#if defined(PLATFORM_X86) && !defined(__ILP32__)
 static uint32_t do_crc32_incremental_generic(const void* data, size_t length, uint32_t init) {
 	// use optimised ASM on x86 platforms
 	crcutil_interface::UINT64 tmp = init;
 	crc->Compute(data, length, &tmp);
 	return (uint32_t)tmp;
 }
+
 #else
+// don't use crcutil
+
 static uint32_t* HEDLEY_RESTRICT crc_slice_table;
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 # if defined(__GNUC__) || defined(__clang__)
@@ -121,33 +128,70 @@ static void generate_crc32_slice_table() {
 		#endif
 	}
 }
+
+#define GENERIC_CRC_INIT generate_crc32_slice_table()
 #endif
 
-extern "C" {
-	crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
-	int _crc32_isa = ISA_GENERIC;
+
+namespace RapidYenc {
+
+// workaround MSVC complaining "unary minus operator applied to unsigned type, result still unsigned"
+#define NEGATE(n) (uint32_t)(-((int32_t)(n)))
+uint32_t crc32_multiply_generic(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;
 }
+#undef NEGATE
 
+const uint32_t crc_power[32] = { // pre-computed 2^(2^n)
+	0x40000000, 0x20000000, 0x08000000, 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
+};
 
-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_);
-	return (uint32_t)crc1_;
+uint32_t crc32_shift_generic(uint32_t crc1, uint32_t n) {
+	uint32_t result = crc1;
+#ifdef __GNUC__
+	while(n) {
+		result = crc32_multiply_generic(result, crc_power[__builtin_ctz(n)]);
+		n &= n-1;
+	}
+#elif defined(_MSC_VER)
+	unsigned long power;
+	while(_BitScanForward(&power, n)) {
+		result = crc32_multiply_generic(result, crc_power[power]);
+		n &= n-1;
+	}
+#else
+	unsigned power = 0;
+	while(n) {
+		if(n & 1) {
+			result = crc32_multiply_generic(result, crc_power[power]);
+		}
+		n >>= 1;
+		power++;
+	}
+#endif
+	return result;
 }
+} // namespace
+
 
-uint32_t do_crc32_zeros(uint32_t crc1, size_t len) {
-	crcutil_interface::UINT64 crc_ = crc1;
-	crc->CrcOfZeroes(len, &crc_);
-	return (uint32_t)crc_;
+namespace RapidYenc {
+	crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
+	crc_mul_func _crc32_shift = &crc32_shift_generic;
+	crc_mul_func _crc32_multiply = &crc32_multiply_generic;
+	int _crc32_isa = ISA_GENERIC;
 }
 
-void crc_clmul_set_funcs();
-void crc_clmul256_set_funcs();
-void crc_arm_set_funcs();
 
-#ifdef PLATFORM_X86
-int cpu_supports_crc_isa();
-#endif
 
 #if defined(PLATFORM_ARM) && defined(_WIN32)
 # define WIN32_LEAN_AND_MEAN
@@ -175,14 +219,16 @@ static unsigned long getauxval(unsigned long cap) {
 #  endif
 # endif
 #endif
-void crc_init() {
-	crc = crcutil_interface::CRC::Create(
-		0xEDB88320, 0, 32, true, 0, 0, 0, 0, NULL);
-	// instance never deleted... oh well...
-	
-#if !defined(PLATFORM_X86) || defined(__ILP32__)
-	generate_crc32_slice_table();
+#if defined(__riscv) && defined(__has_include)
+# if __has_include(<asm/hwprobe.h>)
+#  include <asm/hwprobe.h>
+#  include <asm/unistd.h>
+#  include <unistd.h>
+# endif
 #endif
+
+void RapidYenc::crc32_init() {
+	GENERIC_CRC_INIT;
 	
 #ifdef PLATFORM_X86
 	int support = cpu_supports_crc_isa();
@@ -193,31 +239,59 @@ void crc_init() {
 #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
-# elif defined(AT_HWCAP) && defined(HWCAP_CRC32)
-		getauxval(AT_HWCAP) & HWCAP_CRC32
-# elif defined(ANDROID_CPU_FAMILY_ARM) && defined(__aarch64__)
-		android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_CRC32
-# 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 */
+	int supports_crc = 0;
+	int supports_pmull = 0;
+	size_t len = sizeof(supports_crc);
+	if(sysctlbyname("hw.optional.armv8_crc32", &supports_crc, &len, NULL, 0))
+		supports_crc = 0;
+	if(sysctlbyname("hw.optional.arm.FEAT_PMULL", &supports_pmull, &len, NULL, 0))
+		supports_pmull = 0;
 # else
-		false
+	bool supports_crc = false;
+	bool supports_pmull = false;
+#  if defined(AT_HWCAP2) && defined(HWCAP2_CRC32)
+	supports_crc = getauxval(AT_HWCAP2) & HWCAP2_CRC32;
+#  elif defined(AT_HWCAP) && defined(HWCAP_CRC32)
+	supports_crc = getauxval(AT_HWCAP) & HWCAP_CRC32;
+#  elif defined(ANDROID_CPU_FAMILY_ARM) && defined(__aarch64__)
+	supports_crc = android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_CRC32;
+	supports_pmull = android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_PMULL;
+#  elif defined(ANDROID_CPU_FAMILY_ARM) /* aarch32 */
+	supports_crc = android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_CRC32;
+	supports_pmull = android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_PMULL;
+#  elif defined(_WIN32)
+	supports_crc = IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE);
+	supports_pmull = IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE);
+#  else
+	#ifdef __ARM_FEATURE_CRC32
+	supports_crc = true; /* assume available if compiled as such */
+	#endif
+	#ifdef __ARM_FEATURE_CRYPTO
+	supports_pmull = true;
+	#endif
+#  endif
+#  if defined(AT_HWCAP2) && defined(HWCAP2_PMULL)
+	supports_pmull = getauxval(AT_HWCAP2) & HWCAP2_PMULL;
+#  elif defined(AT_HWCAP) && defined(HWCAP_PMULL)
+	supports_pmull = getauxval(AT_HWCAP) & HWCAP_PMULL;
+#  endif
 # endif
-	) {
+	
+	if(supports_crc) {
 		crc_arm_set_funcs();
+		if(supports_pmull) crc_pmull_set_funcs();
 	}
 #endif
+#ifdef __riscv
+# if defined(RISCV_HWPROBE_KEY_IMA_EXT_0) && defined(__NR_riscv_hwprobe)
+	const int rv_hwprobe_ext_zbc = 1 << 7, rv_hwprobe_ext_zbkc = 1 << 9;
+	struct riscv_hwprobe p;
+	p.key = RISCV_HWPROBE_KEY_IMA_EXT_0;
+	if(!syscall(__NR_riscv_hwprobe, &p, 1, 0, NULL, 0)) {
+		if(p.value & (rv_hwprobe_ext_zbc | rv_hwprobe_ext_zbkc)) {
+			crc_riscv_set_funcs();
+		}
+	}
+# endif
+#endif
 }

package/src/crc.h

@@ -1,27 +1,91 @@
 #ifndef __YENC_CRC_H
 #define __YENC_CRC_H
+#include <stdlib.h> // for llabs
 
-#ifdef __cplusplus
-extern "C" {
+#if !defined(__GNUC__) && defined(_MSC_VER)
+# include <intrin.h>
 #endif
 
+namespace RapidYenc {
 
 
 typedef uint32_t (*crc_func)(const void*, size_t, uint32_t);
 extern crc_func _do_crc32_incremental;
-extern int _crc32_isa;
-#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();
+extern int _crc32_isa;
+static inline uint32_t crc32(const void* data, size_t length, uint32_t init) {
+	return (*_do_crc32_incremental)(data, length, init);
+}
 static inline int crc32_isa_level() {
 	return _crc32_isa;
 }
 
 
-
-#ifdef __cplusplus
-}
+// computes `n % 0xffffffff` (well, almost), using some bit-hacks
+static inline uint32_t crc32_powmod(uint64_t n) {
+#ifdef __GNUC__
+	unsigned res;
+	unsigned carry = __builtin_uadd_overflow(n >> 32, n, &res);
+	res += carry;
+	return res;
+#elif defined(_MSC_VER) && defined(PLATFORM_X86)
+	unsigned res;
+	unsigned char carry = _addcarry_u32(0, n >> 32, n, &res);
+	_addcarry_u32(carry, res, 0, &res);
+	return res;
+#else
+	n = (n >> 32) + (n & 0xffffffff);
+	n += n >> 32;
+	return n;
 #endif
+}
+// computes `crc32_powmod(n*8)` avoiding overflow
+static inline uint32_t crc32_bytepow(uint64_t n) {
+#if defined(__GNUC__) || defined(_MSC_VER)
+	unsigned res = crc32_powmod(n);
+# ifdef _MSC_VER
+	return _rotl(res, 3);
+# else
+	return (res << 3) | (res >> 29);
+# endif
+#else
+	n = (n >> 32) + (n & 0xffffffff);
+	n <<= 3;
+	n += n >> 32;
+	return n;
 #endif
+}
+
+typedef uint32_t (*crc_mul_func)(uint32_t, uint32_t);
+extern crc_mul_func _crc32_shift;
+extern crc_mul_func _crc32_multiply;
+static inline uint32_t crc32_shift(uint32_t a, uint32_t b) {
+	return (*_crc32_shift)(a, b);
+}
+static inline uint32_t crc32_multiply(uint32_t a, uint32_t b) {
+	return (*_crc32_multiply)(a, b);
+}
+
+static inline uint32_t crc32_combine(uint32_t crc1, uint32_t crc2, uint64_t len2) {
+	return crc32_shift(crc1, crc32_bytepow(len2)) ^ crc2;
+}
+static inline uint32_t crc32_zeros(uint32_t crc1, uint64_t len) {
+	return ~crc32_shift(~crc1, crc32_bytepow(len));
+}
+static inline uint32_t crc32_unzero(uint32_t crc1, uint64_t len) {
+	return ~crc32_shift(~crc1, ~crc32_bytepow(len));
+}
+static inline uint32_t crc32_2pow(int64_t n) {
+	uint32_t sign = (uint32_t)(n >> 63);
+	return crc32_shift(0x80000000, crc32_powmod(llabs(n)) ^ sign);
+}
+static inline uint32_t crc32_256pow(uint64_t n) {
+	return crc32_shift(0x80000000, crc32_bytepow(n));
+}
+
+void crc32_init();
+
+
+
+} // namespace
+#endif // defined(__YENC_CRC_H)