yencode 1.1.3 → 1.1.5

package/README.md

@@ -129,7 +129,8 @@ int decodeTo(Buffer data, Buffer output, bool stripDots=false)
 Same as above, but instead of returning a Buffer, writes it to the supplied
 *output* Buffer. Returns the length of the decoded data.  
 Note that the *output* Buffer must be at least large enough to hold the largest
-possible output size (i.e. length of the input), otherwise an error is thrown.
+possible output size (i.e. length of the input), otherwise an error is thrown.  
+The *data* and *output* Buffers can be the same, for in-situ decoding.
 
 Object decodeChunk\(Buffer data \[, string state=null\]\[, Buffer output\]\)
 -----------------------------------------------------------------------------
@@ -142,7 +143,7 @@ designed to incrementally process a stream from the network, and will perform NN
 *state* is the current state of the incremental decode. Set to *null* if this is starting the decode of a new article, otherwise this should be set to the value of *state* given from the previous invocation of *decodeChunk*  
 If *output* is supplied, the output will be written here \(see *decodeTo* for notes
 on required size\), otherwise a new buffer will be created where the output will be
-written to.
+written to. The *data* and *output* Buffers can be the same, for in-situ decoding.
 
 Returns an object with the following keys:
 

package/binding.gyp

@@ -43,10 +43,20 @@
       }],
       ['OS!="win" and enable_native_tuning!=0', {
         "defines": ["YENC_BUILD_NATIVE=1"]
+      }],
+      ['OS!="win"', {
+        "variables": {
+          "missing_memalign%": "<!(<!(echo ${CC_target:-${CC:-cc}}) -c src/test_alignalloc.c -o /dev/null -Werror 2>/dev/null || echo failed)",
+        },
+        "conditions": [
+          ['missing_memalign!=""', {
+            "defines": ["_POSIX_C_SOURCE=200112L"],
+          }]
+        ]
       }]
     ],
     "cflags": ["-Wno-unused-function"],
-    "cxxflags": ["-Wno-unused-function"],
+    "cxxflags": ["-Wno-unused-function", "-std=c++03", "-D_POSIX_C_SOURCE=200112L"],
     "xcode_settings": {
       "OTHER_CFLAGS": ["-Wno-unused-function"],
       "OTHER_CXXFLAGS": ["-Wno-unused-function"]
@@ -64,7 +74,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"],
+      "dependencies": ["crcutil", "yencode_sse2", "yencode_ssse3", "yencode_clmul", "yencode_clmul256", "yencode_avx", "yencode_avx2", "yencode_vbmi2", "yencode_neon", "yencode_armcrc", "yencode_rvv"],
       "sources": [
         "src/yencode.cc",
         "src/platform.cc",
@@ -221,7 +231,7 @@
       "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
       "conditions": [
         ['target_arch in "ia32 x64" and OS!="win"', {
-          "variables": {"supports_vpclmul%": "<!(<!(echo ${CC_target:-${CC:-cc}}) -MM -E src/crc_folding_256.cc -mavx2 -mvpclmulqdq 2>/dev/null || true)"},
+          "variables": {"supports_vpclmul%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/crc_folding_256.cc -mavx2 -mvpclmulqdq 2>/dev/null || true)"},
           "conditions": [
             ['supports_vpclmul!=""', {
               "cflags": ["-mavx2", "-mvpclmulqdq", "-mpclmul"],
@@ -253,7 +263,10 @@
       "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
       "conditions": [
         ['target_arch in "ia32 x64" and OS!="win"', {
-          "variables": {"supports_vbmi2%": "<!(<!(echo ${CC_target:-${CC:-cc}}) -MM -E src/encoder_vbmi2.cc -mavx512vl -mavx512vbmi2 2>/dev/null || true)"},
+          "variables": {
+            "supports_vbmi2%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/encoder_vbmi2.cc -mavx512vl -mavx512vbmi2 2>/dev/null || true)",
+            "supports_avx10%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/encoder_vbmi2.cc -mavx512vl -mno-evex512 2>/dev/null || true)"
+          },
           "conditions": [
             ['supports_vbmi2!=""', {
               "cflags": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
@@ -262,6 +275,14 @@
                 "OTHER_CFLAGS": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
                 "OTHER_CXXFLAGS": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
               }
+            }],
+            ['supports_avx10!=""', {
+              "cflags": ["-mno-evex512"],
+              "cxxflags": ["-mno-evex512"],
+              "xcode_settings": {
+                "OTHER_CFLAGS": ["-mno-evex512"],
+                "OTHER_CXXFLAGS": ["-mno-evex512"],
+              }
             }]
           ]
         }],
@@ -285,11 +306,11 @@
       "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
       "conditions": [
         ['target_arch=="arm"', {
-          "cflags": ["-mfpu=neon"],
-          "cxxflags": ["-mfpu=neon"],
+          "cflags": ["-mfpu=neon","-fno-lto"],
+          "cxxflags": ["-mfpu=neon","-fno-lto"],
           "xcode_settings": {
-            "OTHER_CFLAGS": ["-mfpu=neon"],
-            "OTHER_CXXFLAGS": ["-mfpu=neon"],
+            "OTHER_CFLAGS": ["-mfpu=neon","-fno-lto"],
+            "OTHER_CXXFLAGS": ["-mfpu=neon","-fno-lto"],
           }
         }],
         ['target_arch=="arm64"', {
@@ -299,6 +320,48 @@
         }]
       ]
     },
+    {
+      "target_name": "yencode_rvv",
+      "type": "static_library",
+      "sources": [
+        "src/encoder_rvv.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_rvv%": "<!(<!(echo ${CXX_target:-${CXX:-c++}}) -MM -E src/encoder_rvv.cc -march=rv64gcv 2>/dev/null || true)"},
+          "conditions": [
+            ['supports_rvv!=""', {
+              "cflags": ["-march=rv64gcv"],
+              "cxxflags": ["-march=rv64gcv"],
+              "xcode_settings": {
+                "OTHER_CFLAGS": ["-march=rv64gcv"],
+                "OTHER_CXXFLAGS": ["-march=rv64gcv"],
+              }
+            }]
+          ]
+        }],
+        ['target_arch=="riscv32" and OS!="win"', {
+          "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=rv32gcv"],
+              "cxxflags": ["-march=rv32gcv"],
+              "xcode_settings": {
+                "OTHER_CFLAGS": ["-march=rv32gcv"],
+                "OTHER_CXXFLAGS": ["-march=rv32gcv"],
+              }
+            }]
+          ]
+        }]
+      ]
+    },
     {
       "target_name": "yencode_armcrc",
       "type": "static_library",
@@ -326,11 +389,11 @@
           }
         }],
         ['OS!="win" and target_arch=="arm"', {
-          "cflags": ["-mfpu=fp-armv8"],
-          "cxxflags": ["-mfpu=fp-armv8"],
+          "cflags": ["-mfpu=fp-armv8","-fno-lto"],
+          "cxxflags": ["-mfpu=fp-armv8","-fno-lto"],
           "xcode_settings": {
-            "OTHER_CFLAGS": ["-mfpu=fp-armv8"],
-            "OTHER_CXXFLAGS": ["-mfpu=fp-armv8"]
+            "OTHER_CFLAGS": ["-mfpu=fp-armv8","-fno-lto"],
+            "OTHER_CXXFLAGS": ["-mfpu=fp-armv8","-fno-lto"]
           }
         }]
       ]

package/index.js

@@ -3,6 +3,7 @@
 var y = require('./build/Release/yencode.node');
 
 var toBuffer = Buffer.alloc ? Buffer.from : Buffer;
+var bufferSlice = Buffer.prototype.readBigInt64BE ? Buffer.prototype.subarray : Buffer.prototype.slice;
 
 var nl = toBuffer([13, 10]);
 var RE_BADCHAR = /\r\n\0/g;
@@ -76,28 +77,28 @@ var decoderParseLines = function(lines, ydata) {
 	for(var i=0; i<lines.length; i++) {
 		var yprops = {};
 		
-		var line = lines[i].substr(2); // cut off '=y'
+		var line = lines[i].substring(2); // cut off '=y'
 		// parse tag
 		var p = line.indexOf(' ');
-		var tag = (p<0 ? line : line.substr(0, p));
-		line = line.substr(tag.length+1).trim();
+		var tag = (p<0 ? line : line.substring(0, p));
+		line = line.substring(tag.length+1).trim();
 		
 		// parse props
 		var m = line.match(RE_YPROP);
 		while(m) {
 			if(m.index != 0) {
-				warnings.push(DecoderWarning('ignored_line_data', 'Unknown additional data ignored: "' + line.substr(0, m.index) + '"'));
+				warnings.push(DecoderWarning('ignored_line_data', 'Unknown additional data ignored: "' + line.substring(0, m.index) + '"'));
 			}
 			var prop = m[1], val;
 			var valPos = m.index + m[0].length;
 			if(tag == 'begin' && prop == 'name') {
 				// special treatment of filename - the value is the rest of the line (can include spaces)
-				val = line.substr(valPos);
+				val = line.substring(valPos);
 				line = '';
 			} else {
 				p = line.indexOf(' ', valPos);
-				val = (p<0 ? line.substr(valPos) : line.substr(valPos, p-valPos));
-				line = line.substr(valPos + val.length +1);
+				val = (p<0 ? line.substring(valPos) : line.substring(valPos, p));
+				line = line.substring(valPos + val.length +1);
 			}
 			if(prop in yprops) {
 				warnings.push(DecoderWarning('duplicate_property', 'Duplicate property encountered: `' + prop + '`'));
@@ -139,7 +140,7 @@ module.exports = {
 			prev = '\r\n';
 		
 		if(Buffer.isBuffer(prev)) prev = prev.toString();
-		prev = prev.substr(-4); // only care about the last 4 chars of previous state
+		prev = prev.slice(-4); // only care about the last 4 chars of previous state
 		if(prev == '\r\n.=') prev = '\r\n='; // aliased after dot stripped
 		if(data.length == 0) return {
 			read: 0,
@@ -151,7 +152,7 @@ module.exports = {
 		var state = decodePrev.indexOf(prev);
 		if(state < 0) {
 			for(var l=-3; l<0; i++) {
-				state = decodePrev.indexOf(prev.substr(l));
+				state = decodePrev.indexOf(prev.slice(l));
 				if(state >= 0) break;
 			}
 			if(state < 0) state = decodePrev.indexOf('');
@@ -195,12 +196,13 @@ module.exports = {
 		
 		if(!Buffer.isBuffer(data)) data = toBuffer(data);
 		
-		filename = toBuffer(filename.replace(RE_BADCHAR, '').substr(0, 256), exports.encoding);
+		filename = toBuffer(filename.replace(RE_BADCHAR, '').substring(0, 256), exports.encoding);
+		var e = encodeCrc(data, line_size);
 		return Buffer.concat([
 			toBuffer('=ybegin line='+line_size+' size='+data.length+' name='),
 			filename, nl,
-			y.encode(data, line_size),
-			toBuffer('\r\n=yend size='+data.length+' crc32=' + y.crc32(data).toString('hex'))
+			e.output,
+			toBuffer('\r\n=yend size='+data.length+' crc32=' + e.crc32.toString('hex'))
 		]);
 	},
 	multi_post: function(filename, size, parts, line_size) {
@@ -214,7 +216,7 @@ module.exports = {
 		
 		// find '=ybegin' to know where the yEnc data starts
 		var yencStart;
-		if(data.slice(0, 8).toString('hex') == '3d79626567696e20' /*=ybegin */) {
+		if(bufferSlice.call(data, 0, 8).toString('hex') == '3d79626567696e20' /*=ybegin */) {
 			// common case: starts right at the beginning
 			yencStart = 0;
 		} else {
@@ -231,10 +233,10 @@ module.exports = {
 		var sp = yencStart;
 		var p = bufferFind(data, '\r\n', yencStart+8);
 		while(p > 0) {
-			var line = data.slice(sp, p).toString(this.encoding).trim();
+			var line = bufferSlice.call(data, sp, p).toString(this.encoding).trim();
 			lines.push(line);
 			sp = p+2;
-			if(line.substr(0, 6) == '=yend ') { // no data in post
+			if(line.substring(0, 6) == '=yend ') { // no data in post
 				ret.yencEnd = sp;
 				break;
 			}
@@ -252,7 +254,7 @@ module.exports = {
 		var warnings = decoderParseLines(lines, ydata);
 		
 		if(!ret.yencEnd) {
-			var yencEnd = bufferFindRev(data.slice(ret.dataStart), '\r\n=yend ');
+			var yencEnd = bufferFindRev(bufferSlice.call(data, ret.dataStart), '\r\n=yend ');
 			if(yencEnd < 0)
 				return DecoderError('no_end_found', 'yEnd end marker not found');
 			
@@ -265,7 +267,7 @@ module.exports = {
 				ret.yencEnd = p;
 			} else
 				ret.yencEnd = p+2;
-			var endLine = data.slice(yencEnd+2, p).toString(this.encoding).trim();
+			var endLine = bufferSlice.call(data, yencEnd+2, p).toString(this.encoding).trim();
 			
 			warnings = warnings.concat(decoderParseLines([endLine], ydata));
 		}
@@ -321,7 +323,7 @@ module.exports = {
 			warnings.push(DecoderWarning('size_mismatch', 'Size specified for part exceeds size specified for whole file'));
 		
 		if(ret.dataStart) {
-			ret.data = y.decode(data.slice(ret.dataStart, ret.dataEnd), isRaw);
+			ret.data = y.decode(bufferSlice.call(data, ret.dataStart, ret.dataEnd), !!isRaw);
 			ret.crc32 = y.crc32(ret.data);
 			var hexCrc = ret.crc32.toString('hex');
 			
@@ -360,7 +362,7 @@ function YEncoder(filename, size, parts, line_size) {
 	this.pos = 0;
 	this.crc = toBuffer([0,0,0,0]);
 	
-	filename = toBuffer(filename.replace(RE_BADCHAR, '').substr(0, 256), exports.encoding);
+	filename = toBuffer(filename.replace(RE_BADCHAR, '').substring(0, 256), exports.encoding);
 	if(parts > 1) {
 		this.yInfo = Buffer.concat([
 			toBuffer(' total='+parts+' line='+line_size+' size='+size+' name='),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yencode",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "SIMD accelerated yEnc encoder/decoder and CRC32 calculator",
   "keywords": [
     "yenc",
@@ -21,6 +21,7 @@
     "install": "node-gyp rebuild"
   },
   "gypfile": true,
+  "type": "commonjs",
   "bugs": {
     "url": "https://github.com/animetosho/node-yencode/issues"
   },

package/src/common.h

@@ -57,18 +57,18 @@
 
 
 // MSVC compatibility
-#if ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)) && !defined(__clang__)
+#if ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)) && defined(_MSC_VER) && !defined(__clang__)
 	#define __SSE2__ 1
 	#define __SSSE3__ 1
 	#define __SSE4_1__ 1
-	#if defined(_MSC_VER) && _MSC_VER >= 1600
+	#if _MSC_VER >= 1600 && defined(__SSE2__)
 		#define __POPCNT__ 1
 		#define __LZCNT__ 1
 	#endif
 	#if !defined(__AVX__) && (_MSC_VER >= 1700 && defined(__SSE2__))
 		#define __AVX__ 1
 	#endif
-	#if !defined(__AVX2__) && (_MSC_VER >= 1800 && defined(__SSE2__))
+	#if !defined(__AVX2__) && (_MSC_VER >= 1800 && defined(__AVX__))
 		#define __AVX2__ 1
 		#define __BMI2__ 1
 	#endif
@@ -145,6 +145,13 @@
 
 #endif
 
+#if defined(__ARM_NEON) && defined(__has_include)
+# if !__has_include(<arm_neon.h>)
+#  undef __ARM_NEON
+HEDLEY_WARNING("NEON has been disabled due to missing arm_neon.h");
+# endif
+#endif
+
 #ifdef __ARM_NEON
 # include <arm_neon.h>
 
@@ -214,17 +221,38 @@ bool cpu_supports_neon();
 
 #ifdef PLATFORM_X86
 enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
 	ISA_FEATURE_POPCNT = 0x1,
 	ISA_FEATURE_LZCNT = 0x2,
+	ISA_FEATURE_EVEX512 = 0x4, // AVX512 support
 	ISA_LEVEL_SSE2 = 0x100,
 	ISA_LEVEL_SSSE3 = 0x200,
 	ISA_LEVEL_SSE41 = 0x300,
 	ISA_LEVEL_SSE4_POPCNT = 0x301,
+	ISA_LEVEL_PCLMUL = 0x340,
 	ISA_LEVEL_AVX = 0x381, // same as above, just used as a differentiator for `cpu_supports_isa`
 	ISA_LEVEL_AVX2 = 0x403, // also includes BMI1/2 and LZCNT
-	ISA_LEVEL_AVX3 = 0x503, // SKX variant; AVX512VL + AVX512BW
-	ISA_LEVEL_VBMI2 = 0x603 // ICL
+	ISA_LEVEL_VPCLMUL = 0x440,
+	ISA_LEVEL_AVX3 = 0x507, // SKX variant; AVX512VL + AVX512BW
+	ISA_LEVEL_VBMI2 = 0x603 // ICL, AVX10
+};
+#elif defined(PLATFORM_ARM)
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
+	ISA_FEATURE_CRC = 8,
+	ISA_LEVEL_NEON = 0x1000
 };
+#elif defined(__riscv)
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
+	ISA_LEVEL_RVV = 0x10000
+};
+#else
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0
+};
+#endif
+#ifdef PLATFORM_X86
 #ifdef _MSC_VER
 // native tuning not supported in MSVC
 # define ISA_NATIVE ISA_LEVEL_SSE2
@@ -256,6 +284,16 @@ enum YEncDecIsaLevel {
 int cpu_supports_isa();
 #endif // PLATFORM_X86
 
+
+#ifdef __riscv
+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
+#endif
+
+
 #include <string.h>
 #if !defined(_MSC_VER) || defined(_STDINT) || _MSC_VER >= 1900
 # include <stdint.h>

package/src/crc.cc

@@ -3,13 +3,130 @@
 #include "interface.h"
 crcutil_interface::CRC* crc = NULL;
 
+#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;
 }
-crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
+#else
+static uint32_t* HEDLEY_RESTRICT crc_slice_table;
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+# if defined(__GNUC__) || defined(__clang__)
+#  define bswap32 __builtin_bswap32
+# else
+static inline uint32_t bswap32(uint32_t x) {
+	return (x >> 24) | ((x >> 8) & 0x0000FF00) | ((x << 8) & 0x00FF0000) | (x << 24);
+}
+# endif
+#endif
 
+#define CRC32_GENERIC_CHAINS 4 // newer processors may prefer 8
+static uint32_t do_crc32_incremental_generic(const void* data, size_t length, uint32_t init) {
+	const uint32_t* crc_base_table = crc_slice_table + 4*256; // this also seems to help MSVC's optimiser, which otherwise keeps trying to add to crc_slice_table every time it's referenced
+	uint32_t crc[CRC32_GENERIC_CHAINS]; // Clang seems to be more spill happy with an array over individual variables :(
+	crc[0] = ~init;
+	uint8_t* current8 = (uint8_t*)data;
+	
+	// align to multiple of 4
+	if(((uintptr_t)current8 & 1) && length >= 1) {
+		crc[0] = (crc[0] >> 8) ^ crc_base_table[(crc[0] & 0xFF) ^ *current8++];
+		length--;
+	}
+	if(((uintptr_t)current8 & 2) && length >= 2) {
+		crc[0] = (crc[0] >> 8) ^ crc_base_table[(crc[0] & 0xFF) ^ *current8++];
+		crc[0] = (crc[0] >> 8) ^ crc_base_table[(crc[0] & 0xFF) ^ *current8++];
+		length -= 2;
+	}
+	
+	uint8_t* end8 = current8 + length;
+	uint32_t* current = (uint32_t*)current8;
+	if(length >= 8*CRC32_GENERIC_CHAINS-4) {
+		size_t lenMain = ((length-(CRC32_GENERIC_CHAINS-1)*4) / 4);
+		uint32_t* end = current + (lenMain / CRC32_GENERIC_CHAINS) * CRC32_GENERIC_CHAINS;
+		for(int c=1; c<CRC32_GENERIC_CHAINS; c++)
+			crc[c] = 0;
+		while(current != end) {
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+			#define CRC_PROC4(v, in) \
+				v ^= bswap32(in); \
+				v = crc_slice_table[v >> 24] ^ crc_slice_table[0x100L + ((v >> 16) & 0xff)] ^ crc_slice_table[0x200L + ((v >> 8) & 0xff)] ^ crc_slice_table[0x300L + (v & 0xff)]
+#else
+			#define CRC_PROC4(v, in) \
+				v ^= (in); \
+				v = crc_slice_table[v >> 24] ^ crc_slice_table[0x100L + ((v >> 16) & 0xff)] ^ crc_slice_table[0x200L + ((v >> 8) & 0xff)] ^ crc_slice_table[0x300L + (v & 0xff)]
+#endif
+			for(int c=0; c<CRC32_GENERIC_CHAINS; c++) {
+				CRC_PROC4(crc[c], *current);
+				current++;
+			}
+		}
+		// aggregate accumulators
+		current8 = (uint8_t*)current;
+		#if (CRC32_GENERIC_CHAINS & (CRC32_GENERIC_CHAINS-1)) == 0
+		// assume that lengths which are a multiple of 4/8/16/32 are common
+		if((end8 - current8) & (CRC32_GENERIC_CHAINS*4)) {
+			CRC_PROC4(crc[0], *current);
+			current8 += 4;
+			
+			for(int c=1; c<CRC32_GENERIC_CHAINS; c++) {
+				for(int i=0; i<4; i++)
+					crc[c] = (crc[c] >> 8) ^ crc_base_table[(crc[c] & 0xff) ^ *current8++];
+				crc[(c+1) & ~CRC32_GENERIC_CHAINS] ^= crc[c];
+			}
+		} else
+		#endif
+		#undef CRC_PROC4
+		for(int c=1; c<CRC32_GENERIC_CHAINS; c++) {
+			for(int i=0; i<4; i++)
+				crc[0] = (crc[0] >> 8) ^ crc_base_table[(crc[0] & 0xff) ^ *current8++];
+			crc[0] ^= crc[c];
+		}
+	}
+	
+	// tail loop
+	while(current8 != end8) {
+		crc[0] = (crc[0] >> 8) ^ crc_base_table[(crc[0] & 0xFF) ^ *current8++];
+	}
+	return ~crc[0];
+}
+static void generate_crc32_slice_table() {
+	crc_slice_table = (uint32_t*)malloc(5*256*sizeof(uint32_t));
+	// generate standard byte-by-byte table
+	uint32_t* crc_base_table = crc_slice_table + 4*256;
+	for(int v=0; v<256; v++) {
+		uint32_t crc = v;
+		for(int j = 0; j < 8; j++) {
+			crc = (crc >> 1) ^ (-(int32_t)(crc & 1) & 0xEDB88320);
+		}
+		crc_base_table[v] = crc;
+	}
+	
+	// generate slice-by-4 shifted across for X independent chains
+	for(int v=0; v<256; v++) {
+		uint32_t crc = crc_base_table[v];
+		#if CRC32_GENERIC_CHAINS > 1
+		for(int i=0; i<4*CRC32_GENERIC_CHAINS-5; i++)
+			crc = (crc >> 8) ^ crc_base_table[crc & 0xff];
+		for(int i=0; i<4; i++) {
+			crc = (crc >> 8) ^ crc_base_table[crc & 0xff];
+			crc_slice_table[i*256 + v] = crc;
+		}
+		#else
+		for(int i=0; i<4; i++) {
+			crc_slice_table[i*256 + v] = crc;
+			crc = (crc >> 8) ^ crc_base_table[crc & 0xff];
+		}
+		#endif
+	}
+}
+#endif
+
+extern "C" {
+	crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
+	int _crc32_isa = ISA_GENERIC;
+}
 
 
 uint32_t do_crc32_combine(uint32_t crc1, uint32_t crc2, size_t len2) {
@@ -24,9 +141,9 @@ uint32_t do_crc32_zeros(uint32_t crc1, size_t len) {
 	return (uint32_t)crc_;
 }
 
-void crc_clmul_set_funcs(crc_func*);
-void crc_clmul256_set_funcs(crc_func*);
-void crc_arm_set_funcs(crc_func*);
+void crc_clmul_set_funcs();
+void crc_clmul256_set_funcs();
+void crc_arm_set_funcs();
 
 #ifdef PLATFORM_X86
 int cpu_supports_crc_isa();
@@ -39,22 +156,23 @@ int cpu_supports_crc_isa();
 #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__
+# elif defined(__has_include)
+#  if __has_include(<sys/auxv.h>)
+#   include <sys/auxv.h>
+#   ifdef __FreeBSD__
 static unsigned long getauxval(unsigned long cap) {
 	unsigned long ret;
 	elf_aux_info(cap, &ret, sizeof(ret));
 	return ret;
 }
+#   endif
+#   if __has_include(<asm/hwcap.h>)
+#    include <asm/hwcap.h>
+#   endif
+#  endif
 # endif
 #endif
 void crc_init() {
@@ -62,12 +180,16 @@ void crc_init() {
 		0xEDB88320, 0, 32, true, 0, 0, 0, 0, NULL);
 	// instance never deleted... oh well...
 	
+#if !defined(PLATFORM_X86) || defined(__ILP32__)
+	generate_crc32_slice_table();
+#endif
+	
 #ifdef PLATFORM_X86
 	int support = cpu_supports_crc_isa();
 	if(support == 2)
-		crc_clmul256_set_funcs(&_do_crc32_incremental);
+		crc_clmul256_set_funcs();
 	else if(support == 1)
-		crc_clmul_set_funcs(&_do_crc32_incremental);
+		crc_clmul_set_funcs();
 #endif
 #ifdef PLATFORM_ARM
 # ifdef __APPLE__
@@ -95,7 +217,7 @@ void crc_init() {
 		false
 # endif
 	) {
-		crc_arm_set_funcs(&_do_crc32_incremental);
+		crc_arm_set_funcs();
 	}
 #endif
 }

package/src/crc.h

@@ -9,11 +9,15 @@ extern "C" {
 
 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();
+static inline int crc32_isa_level() {
+	return _crc32_isa;
+}
 
 
 

package/src/crc_arm.cc

@@ -16,6 +16,12 @@ HEDLEY_WARNING("CRC32 acceleration has been disabled due to broken arm_acle.h sh
 HEDLEY_WARNING("CRC32 acceleration has been disabled due to broken arm_acle.h shipped in GCC 9.4 [https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100985]. If you need this feature, please use a different compiler or version of GCC");
 # endif
 #endif
+#if defined(__ARM_FEATURE_CRC32) && defined(__has_include)
+# if !__has_include(<arm_acle.h>)
+#  undef __ARM_FEATURE_CRC32
+HEDLEY_WARNING("CRC32 acceleration has been disabled due to missing arm_acle.h");
+# endif
+#endif
 
 #if defined(__ARM_FEATURE_CRC32) || (defined(_M_ARM64) && !defined(__clang__)) // MSVC doesn't support CRC for ARM32
 
@@ -73,7 +79,7 @@ static HEDLEY_ALWAYS_INLINE uint32_t crc_multiply(uint32_t a, uint32_t b) {
 	return res;
 }
 
-static const uint32_t crc_power[] = { // pre-computed 2^n, with first 3 entries removed (saves a shift)
+static const uint32_t crc_power[] = { // pre-computed 2^(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,
@@ -194,11 +200,10 @@ static uint32_t do_crc32_incremental_arm(const void* data, size_t length, uint32
 	return ~arm_crc_calc(~init, (const unsigned char*)data, (long)length);
 }
 
-void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
-	*_do_crc32_incremental = &do_crc32_incremental_arm;
+void crc_arm_set_funcs() {
+	_do_crc32_incremental = &do_crc32_incremental_arm;
+	_crc32_isa = ISA_FEATURE_CRC;
 }
 #else
-void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
-	(void)_do_crc32_incremental;
-}
+void crc_arm_set_funcs() {}
 #endif