yencode 1.1.1 → 1.1.2

package/src/{crc_folding.c → crc_folding.cc}

@@ -19,44 +19,29 @@
 
 #include "crc_common.h"
  
-#if !defined(_MSC_VER) || defined(_STDINT) || _MSC_VER >= 1900
-# include <stdint.h>
-#else
-/* Workaround for older MSVC not supporting stdint.h - just pull it from V8 */
-# include <v8.h>
-#endif
-
-#if (defined(__PCLMUL__) && defined(__SSSE3__) && defined(__SSE4_1__)) || (defined(_MSC_VER) && _MSC_VER >= 1600)
+#if (defined(__PCLMUL__) && defined(__SSSE3__) && defined(__SSE4_1__)) || (defined(_MSC_VER) && _MSC_VER >= 1600 && defined(PLATFORM_X86))
 #include <inttypes.h>
 #include <immintrin.h>
 #include <wmmintrin.h>
 
-#define local static
 
-#ifdef _MSC_VER
-# define ALIGN(_a, v) __declspec(align(_a)) v
-/* Because we don't have dynamic dispatch for AVX, disable it for MSVC builds (only use AVX for -march=native style builds) */
-# undef __AVX__
-# undef __AVX512F__
-# undef __AVX512VL__
-# undef __GFNI__
-#else
-# define ALIGN(_a, v) v __attribute__((aligned(_a)))
+#if defined(__AVX512VL__) && defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
+# define ENABLE_AVX512 1
 #endif
 
 
 // interestingly, MSVC seems to generate better code if using VXORPS over VPXOR
 // original Intel code uses XORPS for many XOR operations, but PXOR is pretty much always better (more port freedom on Intel CPUs). The only advantage of XORPS is that it's 1 byte shorter, an advantage which disappears under AVX as both instructions have the same length
-#ifdef __AVX__
+#if defined(__AVX__) && defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
 # define fold_xor _mm_xor_si128
 #else
-local __m128i fold_xor(__m128i a, __m128i b) {
+static __m128i fold_xor(__m128i a, __m128i b) {
 	return _mm_castps_si128(_mm_xor_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b)));
 }
 #endif
 
-#ifdef __AVX512VL__
-local __m128i do_one_fold_merge(__m128i src, __m128i data) {
+#ifdef ENABLE_AVX512
+static __m128i do_one_fold_merge(__m128i src, __m128i data) {
     const __m128i xmm_fold4 = _mm_set_epi32(
             0x00000001, 0x54442bd4,
             0x00000001, 0xc6e41596);
@@ -68,7 +53,7 @@ local __m128i do_one_fold_merge(__m128i src, __m128i data) {
     );
 }
 #else
-local __m128i do_one_fold(__m128i src) {
+static __m128i do_one_fold(__m128i src) {
     const __m128i xmm_fold4 = _mm_set_epi32(
             0x00000001, 0x54442bd4,
             0x00000001, 0xc6e41596);
@@ -79,7 +64,7 @@ local __m128i do_one_fold(__m128i src) {
 }
 #endif
 
-ALIGN(32, local const unsigned  pshufb_shf_table[60]) = {
+ALIGN_TO(32, static const unsigned  pshufb_shf_table[60]) = {
     0x84838281, 0x88878685, 0x8c8b8a89, 0x008f8e8d, /* shl 15 (16 - 1)/shr1 */
     0x85848382, 0x89888786, 0x8d8c8b8a, 0x01008f8e, /* shl 14 (16 - 3)/shr2 */
     0x86858483, 0x8a898887, 0x8e8d8c8b, 0x0201008f, /* shl 13 (16 - 4)/shr3 */
@@ -97,7 +82,7 @@ ALIGN(32, local const unsigned  pshufb_shf_table[60]) = {
     0x0201008f, 0x06050403, 0x0a090807, 0x0e0d0c0b  /* shl  1 (16 -15)/shr15*/
 };
 
-local void partial_fold(const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1,
+static void partial_fold(const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3, __m128i *xmm_crc_part) {
 
     const __m128i xmm_mask3 = _mm_set1_epi32(0x80808080);
@@ -127,7 +112,7 @@ local void partial_fold(const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1,
     *xmm_crc_part = _mm_shuffle_epi8(*xmm_crc_part, xmm_shl);
     *xmm_crc3 = _mm_or_si128(*xmm_crc3, *xmm_crc_part);
 
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
     *xmm_crc3 = do_one_fold_merge(xmm_a0_0, *xmm_crc3);
 #else
     *xmm_crc3 = fold_xor(
@@ -137,25 +122,21 @@ local void partial_fold(const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1,
 #endif
 }
 
-ALIGN(16, local const unsigned crc_k[]) = {
+ALIGN_TO(16, static const unsigned crc_k[]) = {
     0xccaa009e, 0x00000000, /* rk1 */
     0x751997d0, 0x00000001, /* rk2 */
     0xccaa009e, 0x00000000, /* rk5 */
     0x63cd6124, 0x00000001, /* rk6 */
-    0xf7011640, 0x00000001, /* rk7 */
+    0xf7011641, 0x00000000, /* rk7 */
     0xdb710640, 0x00000001  /* rk8 */
 };
 
-ALIGN(16, local const unsigned crc_mask[4]) = {
-    0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000
-};
-
-ALIGN(16, local const unsigned crc_mask2[4]) = {
+ALIGN_TO(16, static const unsigned crc_mask[4]) = {
     0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
 };
 
-local __m128i reverse_bits_epi8(__m128i src) {
-#ifdef __GFNI__
+static __m128i reverse_bits_epi8(__m128i src) {
+#if defined(__GFNI__) && defined(YENC_BUILD_NATIVE) && YENC_BUILD_NATIVE!=0
     return _mm_gf2p8affine_epi64_epi8(src, _mm_set_epi32(
       0x80402010, 0x08040201,
       0x80402010, 0x08040201
@@ -164,7 +145,8 @@ local __m128i reverse_bits_epi8(__m128i src) {
     __m128i xmm_t0 = _mm_and_si128(src, _mm_set1_epi8(0x0f));
     __m128i xmm_t1 = _mm_and_si128(_mm_srli_epi16(src, 4), _mm_set1_epi8(0x0f));
     xmm_t0 = _mm_shuffle_epi8(_mm_set_epi8(
-      0xf0, 0x70, 0xb0, 0x30, 0xd0, 0x50, 0x90, 0x10, 0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0
+      -16, 112, -80, 48, -48, 80, -112, 16, -32, 96, -96, 32, -64, 64, -128, 0
+      //0xf0, 0x70, 0xb0, 0x30, 0xd0, 0x50, 0x90, 0x10, 0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0
     ), xmm_t0);
     xmm_t1 = _mm_shuffle_epi8(_mm_set_epi8(
       15, 7, 11, 3, 13, 5, 9, 1, 14, 6, 10, 2, 12, 4, 8, 0
@@ -181,7 +163,7 @@ local __m128i reverse_bits_epi8(__m128i src) {
 # define BSWAP32(n) ((((n)&0xff)<<24) | (((n)&0xff00)<<8) | (((n)&0xff0000)>>8) | (((n)&0xff000000)>>24))
 #endif
 
-local uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
+static uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
     unsigned long algn_diff;
     __m128i xmm_t0, xmm_t1, xmm_t2, xmm_t3;
 
@@ -235,7 +217,7 @@ local uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
         xmm_t2 = _mm_load_si128((__m128i *)src + 2);
         xmm_t3 = _mm_load_si128((__m128i *)src + 3);
 
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
         xmm_crc0 = do_one_fold_merge(xmm_crc0, xmm_t0);
         xmm_crc1 = do_one_fold_merge(xmm_crc1, xmm_t1);
         xmm_crc2 = do_one_fold_merge(xmm_crc2, xmm_t2);
@@ -266,7 +248,7 @@ local uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
         xmm_t2 = _mm_load_si128((__m128i *)src + 2);
 
         xmm_t3 = xmm_crc3;
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
         xmm_crc3 = do_one_fold_merge(xmm_crc2, xmm_t2);
         xmm_crc2 = do_one_fold_merge(xmm_crc1, xmm_t1);
         xmm_crc1 = do_one_fold_merge(xmm_crc0, xmm_t0);
@@ -292,7 +274,7 @@ local uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
 
         xmm_t2 = xmm_crc2;
         xmm_t3 = xmm_crc3;
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
         xmm_crc3 = do_one_fold_merge(xmm_crc1, xmm_t1);
         xmm_crc2 = do_one_fold_merge(xmm_crc0, xmm_t0);
 #else
@@ -314,7 +296,7 @@ local uint32_t crc_fold(const unsigned char *src, long len, uint32_t initial) {
         xmm_t0 = _mm_load_si128((__m128i *)src);
 
         xmm_t3 = xmm_crc3;
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
         xmm_crc3 = do_one_fold_merge(xmm_crc0, xmm_t0);
 #else
         xmm_crc3 = _mm_xor_si128(do_one_fold(xmm_crc0), xmm_t0);
@@ -339,8 +321,7 @@ partial:
         &xmm_crc_part);
 done:
 {
-    const __m128i xmm_mask  = _mm_load_si128((__m128i *)crc_mask);
-    const __m128i xmm_mask2 = _mm_load_si128((__m128i *)crc_mask2);
+    const __m128i xmm_mask = _mm_load_si128((__m128i *)crc_mask);
     __m128i x_tmp0, x_tmp1, x_tmp2, crc_fold;
 
     /*
@@ -350,7 +331,7 @@ done:
 
     x_tmp0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x10);
     xmm_crc0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x01);
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
     xmm_crc1 = _mm_ternarylogic_epi32(xmm_crc1, x_tmp0, xmm_crc0, 0x96);
 #else
     xmm_crc1 = _mm_xor_si128(xmm_crc1, x_tmp0);
@@ -359,7 +340,7 @@ done:
 
     x_tmp1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x10);
     xmm_crc1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x01);
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
     xmm_crc2 = _mm_ternarylogic_epi32(xmm_crc2, x_tmp1, xmm_crc1, 0x96);
 #else
     xmm_crc2 = _mm_xor_si128(xmm_crc2, x_tmp1);
@@ -368,7 +349,7 @@ done:
 
     x_tmp2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x10);
     xmm_crc2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x01);
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
     xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, x_tmp2, xmm_crc2, 0x96);
 #else
     xmm_crc3 = _mm_xor_si128(xmm_crc3, x_tmp2);
@@ -388,58 +369,43 @@ done:
     xmm_crc0 = xmm_crc3;
     xmm_crc3 = _mm_slli_si128(xmm_crc3, 4);
     xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);
-#ifdef __AVX512VL__
+#ifdef ENABLE_AVX512
     //xmm_crc3 = _mm_maskz_xor_epi32(14, xmm_crc3, xmm_crc0);
-    xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, xmm_crc0, xmm_mask2, 0x28);
+    xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, xmm_crc0, xmm_mask, 0x28);
 #else
+    xmm_crc0 = _mm_and_si128(xmm_crc0, xmm_mask);
     xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc0);
-    xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask2);
 #endif
 
     /*
      * k7
      */
     xmm_crc1 = xmm_crc3;
-    xmm_crc2 = xmm_crc3;
     crc_fold = _mm_load_si128((__m128i *)crc_k + 2);
 
     xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0);
-#ifdef __AVX512VL__
-    //xmm_crc3 = _mm_maskz_xor_epi32(3, xmm_crc3, xmm_crc2);
-    xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, xmm_crc2, xmm_mask, 0x28);
-#else
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);
-    xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask);
-#endif
-
-    xmm_crc2 = xmm_crc3;
     xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);
-#ifdef __AVX512VL__
-    xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, xmm_crc2, xmm_crc1, 0x69); // NOT(double-XOR)
-    return _mm_extract_epi32(xmm_crc3, 2);
+#ifdef ENABLE_AVX512
+    xmm_crc3 = _mm_ternarylogic_epi32(xmm_crc3, xmm_crc1, xmm_crc1, 0xC3); // NOT(xmm_crc3 ^ xmm_crc1)
 #else
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);
+    xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_mask);
     xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc1);
-    return ~_mm_extract_epi32(xmm_crc3, 2);
 #endif
+    return _mm_extract_epi32(xmm_crc3, 2);
 }
 
 }
 
-static void do_crc32_clmul(const void* data, size_t length, unsigned char out[4]) {
-	uint32_t tmp = crc_fold((const unsigned char*)data, (long)length, 0);
-	UNPACK_4(out, tmp);
-}
-static void do_crc32_incremental_clmul(const void* data, size_t length, unsigned char init[4]) {
-	uint32_t tmp = crc_fold((const unsigned char*)data, (long)length, PACK_4(init));
-	UNPACK_4(init, tmp);
+static uint32_t do_crc32_incremental_clmul(const void* data, size_t length, uint32_t init) {
+	return crc_fold((const unsigned char*)data, (long)length, init);
 }
 
-void crc_clmul_set_funcs(crc_func* _do_crc32, crc_func* _do_crc32_incremental) {
-	*_do_crc32 = &do_crc32_clmul;
+void crc_clmul_set_funcs(crc_func* _do_crc32_incremental) {
 	*_do_crc32_incremental = &do_crc32_incremental_clmul;
 }
 #else
-void crc_clmul_set_funcs(crc_func* _do_crc32, crc_func* _do_crc32_incremental) {}
+void crc_clmul_set_funcs(crc_func* _do_crc32_incremental) {
+    (void)_do_crc32_incremental;
+}
 #endif
 

package/src/decoder.cc

@@ -1,10 +1,13 @@
 #include "common.h"
 
 #include "decoder_common.h"
+#include "decoder.h"
 
-YencDecoderEnd (*_do_decode)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_scalar<false, false>;
-YencDecoderEnd (*_do_decode_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_scalar<true, false>;
-YencDecoderEnd (*_do_decode_end_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_end_scalar<true>;
+extern "C" {
+	YencDecoderEnd (*_do_decode)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_scalar<false, false>;
+	YencDecoderEnd (*_do_decode_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_scalar<true, false>;
+	YencDecoderEnd (*_do_decode_end_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*) = &do_decode_end_scalar<true>;
+}
 
 void decoder_set_sse2_funcs();
 void decoder_set_ssse3_funcs();

package/src/decoder.h

@@ -1,3 +1,11 @@
+#ifndef __YENC_DECODER_H
+#define __YENC_DECODER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 
 // the last state that the decoder was in (i.e. last few characters processed)
 // the state is needed for incremental decoders as its behavior is affected by what it processed last
@@ -25,8 +33,7 @@ extern YencDecoderEnd (*_do_decode)(const unsigned char*HEDLEY_RESTRICT*, unsign
 extern YencDecoderEnd (*_do_decode_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*);
 extern YencDecoderEnd (*_do_decode_end_raw)(const unsigned char*HEDLEY_RESTRICT*, unsigned char*HEDLEY_RESTRICT*, size_t, YencDecoderState*);
 
-template<bool isRaw>
-static inline size_t do_decode(const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, YencDecoderState* state) {
+static inline size_t do_decode(int isRaw, const unsigned char* HEDLEY_RESTRICT src, unsigned char* HEDLEY_RESTRICT dest, size_t len, YencDecoderState* state) {
 	unsigned char* ds = dest;
 	(*(isRaw ? _do_decode_raw : _do_decode))(&src, &ds, len, state);
 	return ds - dest;
@@ -37,3 +44,10 @@ static inline YencDecoderEnd do_decode_end(const unsigned char*HEDLEY_RESTRICT*
 }
 
 void decoder_init();
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

package/src/decoder_avx2_base.h

@@ -30,13 +30,17 @@ static HEDLEY_ALWAYS_INLINE __m256i force_align_read_256(const void* p) {
 }
 
 // _mm256_castsi128_si256, but upper is defined to be 0
-#if defined(__clang__) && __clang_major__ >= 5
+#if (defined(__clang__) && __clang_major__ >= 5 && (!defined(__APPLE__) || __clang_major__ >= 7)) || (defined(__GNUC__) && __GNUC__ >= 10)
 // intrinsic unsupported in GCC 9 and MSVC < 2017
 # define zext128_256 _mm256_zextsi128_si256
 #else
 // technically a cast is incorrect, due to upper 128 bits being undefined, but should usually work fine
 // alternative may be `_mm256_set_m128i(_mm_setzero_si128(), v)` but unsupported on GCC < 7, and most compilers generate a VINSERTF128 instruction for it
-# define zext128_256 _mm256_castsi128_si256
+# ifdef __OPTIMIZE__
+#  define zext128_256 _mm256_castsi128_si256
+# else
+#  define zext128_256(x) _mm256_inserti128_si256(_mm256_setzero_si256(), x, 0)
+# endif
 #endif
 
 
@@ -298,7 +302,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* HEDLEY_RESTRICT src, lon
 						if(LIKELIHOOD(0.002, matchEnd)) {
 							// terminator found
 							// there's probably faster ways to do this, but reverting to scalar code should be good enough
-							len += i;
+							len += (long)i;
 							break;
 						}
 					}
@@ -390,7 +394,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* HEDLEY_RESTRICT src, lon
 							));
 						}
 						if(endFound) {
-							len += i;
+							len += (long)i;
 							break;
 						}
 					}
@@ -489,14 +493,10 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* HEDLEY_RESTRICT src, lon
 #endif
 				{
 					// << 1 byte
-					cmpEqB = _mm256_cmpeq_epi8(_mm256_set1_epi8('='), _mm256_loadu_si256((__m256i *)(src+i-1) + 1));
-#if defined(__tune_znver1__) || defined(__tune_bdver4__)
 					cmpEqA = _mm256_alignr_epi8(cmpEqA, _mm256_inserti128_si256(
-						_mm256_setzero_si256(), _mm256_castsi256_si128(cmpEqA), 1
+						_mm256_set1_epi8('='), _mm256_castsi256_si128(cmpEqA), 1
 					), 15);
-#else
-					cmpEqA = _mm256_alignr_epi8(cmpEqA, _mm256_permute2x128_si256(cmpEqA, cmpEqA, 0x08), 15);
-#endif
+					cmpEqB = _mm256_cmpeq_epi8(_mm256_set1_epi8('='), _mm256_loadu_si256((__m256i *)(src+i-1) + 1));
 					dataA = _mm256_add_epi8(
 						oDataA,
 						_mm256_blendv_epi8(
@@ -523,7 +523,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* HEDLEY_RESTRICT src, lon
 #endif
 			{
 				yencOffset = _mm256_xor_si256(_mm256_set1_epi8(-42), zext128_256(
-					_mm_slli_epi16(_mm_cvtsi32_si128(escFirst), 6)
+					_mm_slli_epi16(_mm_cvtsi32_si128((int)escFirst), 6)
 				));
 			}
 			
@@ -565,7 +565,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* HEDLEY_RESTRICT src, lon
 				p -= popcnt32(mask & 0xffff0);
 				
 				_mm_storeu_si128((__m128i*)(p + XMM_SIZE*3), _mm256_extracti128_si256(dataB, 1));
-				p -= popcnt32(mask >> 20);
+				p -= popcnt32((unsigned int)(mask >> 20));
 #else
 				mask >>= 32;
 				shuf = _mm256_inserti128_si256(

package/src/decoder_common.h

@@ -340,7 +340,7 @@ YencDecoderEnd do_decode_simd(const unsigned char* HEDLEY_RESTRICT* src, unsigne
 	if((uintptr_t)(*src) & ((width-1))) {
 		// find source memory alignment
 		unsigned char* aSrc = (unsigned char*)(((uintptr_t)(*src) + (width-1)) & ~(width-1));
-		int amount = aSrc - *src;
+		int amount = (int)(aSrc - *src);
 		len -= amount;
 		YencDecoderEnd ended = do_decode_scalar<isRaw, searchEnd>(src, dest, amount, pState);
 		if(ended) return ended;
@@ -427,7 +427,7 @@ YencDecoderEnd do_decode_simd(const unsigned char* HEDLEY_RESTRICT* src, unsigne
 		escFirst = (*pState == YDEC_STATE_EQ || *pState == YDEC_STATE_CRLFEQ);
 		
 		// our algorithm may perform an aligned load on the next part, of which we consider 2 bytes (for \r\n. sequence checking)
-		long dLen = len - lenBuffer;
+		long dLen = (long)(len - lenBuffer);
 		dLen = (dLen + (width-1)) & ~(width-1);
 		
 		kernel((const uint8_t*)(*src) + dLen, dLen, p, escFirst, nextMask);

package/src/decoder_neon.cc

@@ -7,9 +7,9 @@
 #include "decoder_common.h"
 
 
-#ifdef _MSC_VER
-# define vld1_u8_align vld1_u8_ex
-# define vld1q_u8_align vld1q_u8_ex
+#if defined(_MSC_VER) && !defined(__clang__)
+# define vld1_u8_align(p, a) vld1_u8_ex(p, a*8)
+# define vld1q_u8_align(p, a) vld1q_u8_ex(p, a*8)
 #elif defined(__GNUC__)
 # define vld1_u8_align(p, n) vld1_u8((uint8_t*)__builtin_assume_aligned(p, n))
 # define vld1q_u8_align(p, n) vld1q_u8((uint8_t*)__builtin_assume_aligned(p, n))
@@ -23,15 +23,13 @@
 #if defined(__clang__) || (defined(__GNUC__) && (defined(__aarch64__) && __GNUC__ >= 8))
 # define vld1q_u8_x2_align(p, n) vld1q_u8_x2((uint8_t*)__builtin_assume_aligned(p, n))
 #else
-HEDLEY_ALWAYS_INLINE uint8x16x2_t vld1q_u8_x2_align(const uint8_t* p, int n) {
-	return (uint8x16x2_t){vld1q_u8_align(p, n), vld1q_u8_align(p+16, n)};
-}
+# define vld1q_u8_x2_align(p, n) vcreate2_u8(vld1q_u8_align(p, (n)/2), vld1q_u8_align((p)+16, (n)/2))
 #endif
 // Clang wrongly assumes alignment on vld1q_u8_x2, and ARMv7 GCC doesn't support the function, so effectively, it can only be used in ARMv8 compilers
 #if defined(__aarch64__) && (defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 9))
 # define vst1q_u8_x2_unaligned vst1q_u8_x2
 #else
-HEDLEY_ALWAYS_INLINE void vst1q_u8_x2_unaligned(uint8_t* p, uint8x16x2_t data) {
+static HEDLEY_ALWAYS_INLINE void vst1q_u8_x2_unaligned(uint8_t* p, uint8x16x2_t data) {
 	vst1q_u8(p, data.val[0]);
 	vst1q_u8(p+16, data.val[1]);
 }
@@ -64,18 +62,20 @@ template<bool isRaw, bool searchEnd>
 HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, long& len, unsigned char* HEDLEY_RESTRICT & p, unsigned char& escFirst, uint16_t& nextMask) {
 	HEDLEY_ASSUME(escFirst == 0 || escFirst == 1);
 	HEDLEY_ASSUME(nextMask == 0 || nextMask == 1 || nextMask == 2);
-	uint8x16_t yencOffset = escFirst ? (uint8x16_t){42+64,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42} : vdupq_n_u8(42);
+	uint8x16_t yencOffset = escFirst ? vmakeq_u8(42+64,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42) : vdupq_n_u8(42);
 #ifdef __aarch64__
 	uint8x16_t nextMaskMix = vdupq_n_u8(0);
-	if(nextMask)
-		nextMaskMix[nextMask-1] = nextMask;
+	if(nextMask == 1)
+		nextMaskMix = vsetq_lane_u8(1, nextMaskMix, 0);
+	if(nextMask == 2)
+		nextMaskMix = vsetq_lane_u8(2, nextMaskMix, 1);
 #else
 	uint8x16_t lfCompare = vdupq_n_u8('\n');
 	if(isRaw) {
 		if(nextMask == 1)
-			lfCompare[0] = '.';
+			lfCompare = vsetq_lane_u8('.', lfCompare, 0);
 		if(nextMask == 2)
-			lfCompare[1] = '.';
+			lfCompare = vsetq_lane_u8('.', lfCompare, 1);
 	}
 #endif
 	long i;
@@ -90,13 +90,13 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 #ifdef __aarch64__
 		cmpA = vqtbx1q_u8(
 			cmpEqA,
-			//                                \n      \r
-			(uint8x16_t){0,0,0,0,0,0,0,0,0,0,255,0,0,255,0,0},
+			//                             \n      \r
+			vmakeq_u8(0,0,0,0,0,0,0,0,0,0,255,0,0,255,0,0),
 			dataA
 		),
 		cmpB = vqtbx1q_u8(
 			cmpEqB,
-			(uint8x16_t){0,0,0,0,0,0,0,0,0,0,255,0,0,255,0,0},
+			vmakeq_u8(0,0,0,0,0,0,0,0,0,0,255,0,0,255,0,0),
 			dataB
 		);
 		if(isRaw) cmpA = vorrq_u8(cmpA, nextMaskMix);
@@ -122,12 +122,12 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 		
 #ifdef __aarch64__
 		if (LIKELIHOOD(0.42 /*guess*/, neon_vect_is_nonzero(vorrq_u8(cmpA, cmpB)))) {
-			cmpA = vandq_u8(cmpA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
-			cmpB = vandq_u8(cmpB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+			cmpA = vandq_u8(cmpA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
+			cmpB = vandq_u8(cmpB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 			uint8x16_t cmpMerge = vpaddq_u8(cmpA, cmpB);
 			uint8x16_t cmpEqMerge = vpaddq_u8(
-				vandq_u8(cmpEqA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128}),
-				vandq_u8(cmpEqB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128})
+				vandq_u8(cmpEqA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128)),
+				vandq_u8(cmpEqB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128))
 			);
 			
 			uint8x16_t cmpCombined = vpaddq_u8(cmpMerge, cmpEqMerge);
@@ -136,8 +136,8 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 			uint32_t mask = vgetq_lane_u32(vreinterpretq_u32_u8(cmpCombined), 0);
 			uint32_t maskEq = vgetq_lane_u32(vreinterpretq_u32_u8(cmpCombined), 1);
 #else
-		cmpA = vandq_u8(cmpA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
-		cmpB = vandq_u8(cmpB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+		cmpA = vandq_u8(cmpA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
+		cmpB = vandq_u8(cmpB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 		// no vpaddq_u8 in ARMv7, so need extra 64-bit VPADD
 		uint8x8_t cmpPacked = vpadd_u8(
 			vpadd_u8(
@@ -150,8 +150,8 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 		cmpPacked = vpadd_u8(cmpPacked, cmpPacked);
 		uint32_t mask = vget_lane_u32(vreinterpret_u32_u8(cmpPacked), 0);
 		if(LIKELIHOOD(0.42, mask != 0)) {
-			uint8x16_t cmpEqMaskedA = vandq_u8(cmpEqA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
-			uint8x16_t cmpEqMaskedB = vandq_u8(cmpEqB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+			uint8x16_t cmpEqMaskedA = vandq_u8(cmpEqA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
+			uint8x16_t cmpEqMaskedB = vandq_u8(cmpEqB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 			uint8x8_t cmpEqPacked = vpadd_u8(
 				vpadd_u8(
 					vget_low_u8(cmpEqMaskedA), vget_high_u8(cmpEqMaskedA)
@@ -170,7 +170,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 				// vext seems to be a cheap operation on ARM, relative to loads, so only avoid it if there's only one load (isRaw only)
 				uint8x16_t tmpData2, nextData;
 				if(isRaw && !searchEnd) {
-					tmpData2 = vld1q_u8_align(src+i + 2 + sizeof(uint8x16_t), 2);
+					tmpData2 = vld1q_u8(src+i + 2 + sizeof(uint8x16_t));
 				} else {
 					nextData = vld1q_u8_align(src+i + sizeof(uint8x16_t)*2, 16); // only 32-bits needed, but there doesn't appear a nice way to do this via intrinsics: https://stackoverflow.com/questions/46910799/arm-neon-intrinsics-convert-d-64-bit-register-to-low-half-of-q-128-bit-regis
 					tmpData2 = vextq_u8(dataB, nextData, 2);
@@ -255,15 +255,15 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 						}
 					}
 #ifdef __aarch64__
-					uint8x16_t match2NlDotBMasked = vandq_u8(match2NlDotB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+					uint8x16_t match2NlDotBMasked = vandq_u8(match2NlDotB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 					uint8x16_t mergeKillDots = vpaddq_u8(
-						vandq_u8(match2NlDotA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128}),
+						vandq_u8(match2NlDotA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128)),
 						match2NlDotBMasked
 					);
 					uint8x8_t mergeKillDots2 = vget_low_u8(vpaddq_u8(mergeKillDots, mergeKillDots));
 #else
-					uint8x16_t match2NlDotMaskedA = vandq_u8(match2NlDotA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
-					uint8x16_t match2NlDotMaskedB = vandq_u8(match2NlDotB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+					uint8x16_t match2NlDotMaskedA = vandq_u8(match2NlDotA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
+					uint8x16_t match2NlDotMaskedB = vandq_u8(match2NlDotB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 					uint8x8_t mergeKillDots2 = vpadd_u8(
 						vpadd_u8(
 							vget_low_u8(match2NlDotMaskedA), vget_high_u8(match2NlDotMaskedA)
@@ -342,11 +342,11 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 #ifdef __aarch64__
 				uint8x16_t vMaskEqA = vqtbl1q_u8(
 					vcombine_u8(maskEqTemp, vdup_n_u8(0)),
-					(uint8x16_t){0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1}
+					vmakeq_u8(0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1)
 				);
 				uint8x16_t vMaskEqB = vqtbl1q_u8(
 					vcombine_u8(maskEqTemp, vdup_n_u8(0)),
-					(uint8x16_t){2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3}
+					vmakeq_u8(2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3)
 				);
 #else
 				uint8x16_t vMaskEqA = vcombine_u8(
@@ -358,8 +358,8 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 					vdup_lane_u8(maskEqTemp, 3)
 				);
 #endif
-				vMaskEqA = vtstq_u8(vMaskEqA, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
-				vMaskEqB = vtstq_u8(vMaskEqB, (uint8x16_t){1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128});
+				vMaskEqA = vtstq_u8(vMaskEqA, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
+				vMaskEqB = vtstq_u8(vMaskEqB, vmakeq_u8(1,2,4,8,16,32,64,128, 1,2,4,8,16,32,64,128));
 				
 				dataA = vsubq_u8(
 					dataA,
@@ -391,7 +391,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 					)
 				);
 			}
-			yencOffset[0] = (escFirst << 6) | 42;
+			yencOffset = vsetq_lane_u8((escFirst << 6) | 42, yencOffset, 0);
 			
 			// all that's left is to 'compress' the data (skip over masked chars)
 			uint32_t counts = 0x08080808 - vget_lane_u32(vreinterpret_u32_u8(vcnt_u8(cmpPacked)), 0);
@@ -439,7 +439,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* HEDLEY_RESTRICT src, lon
 		} else {
 			dataA = vsubq_u8(dataA, yencOffset);
 			dataB = vsubq_u8(dataB, vdupq_n_u8(42));
-			vst1q_u8_x2_unaligned(p, ((uint8x16x2_t){dataA, dataB}));
+			vst1q_u8_x2_unaligned(p, vcreate2_u8(dataA, dataB));
 			p += sizeof(uint8x16_t)*2;
 			escFirst = 0;
 #ifdef __aarch64__