diff --git a/sse2neon.h b/sse2neon.h
index 8e0044a9..8ec819fc 100644
--- a/sse2neon.h
+++ b/sse2neon.h
@@ -1774,7 +1774,7 @@ FORCE_INLINE void _sse2neon_set_fpcr(uint64_t value)
 #if defined(_MSC_VER)
     _WriteStatusReg(ARM64_FPCR, value);
 #else
-    __asm__ __volatile__("msr FPCR, %0" ::"r"(value));  /* write */
+    __asm__ __volatile__("msr FPCR, %0" ::"r"(value)); /* write */
 #endif
 }
 
@@ -2385,7 +2385,7 @@ FORCE_INLINE void _sse2neon_mm_set_flush_zero_mode(unsigned int flag)
 #if defined(__aarch64__) || defined(_M_ARM64)
     _sse2neon_set_fpcr(r.value);
 #else
-    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r)); /* write */
 #endif
 }
 
@@ -2449,7 +2449,7 @@ FORCE_INLINE void _MM_SET_ROUNDING_MODE(int rounding)
 #if defined(__aarch64__) || defined(_M_ARM64)
     _sse2neon_set_fpcr(r.value);
 #else
-    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r)); /* write */
 #endif
 }
 
@@ -8644,9 +8644,9 @@ FORCE_INLINE __m128i _mm_aesenc_si128(__m128i a, __m128i RoundKey)
 #define SSE2NEON_AES_B2W(b0, b1, b2, b3)                 \
     (((uint32_t) (b3) << 24) | ((uint32_t) (b2) << 16) | \
      ((uint32_t) (b1) << 8) | (uint32_t) (b0))
-// muliplying 'x' by 2 in GF(2^8)
+    // muliplying 'x' by 2 in GF(2^8)
 #define SSE2NEON_AES_F2(x) ((x << 1) ^ (((x >> 7) & 1) * 0x011b /* WPOLY */))
-// muliplying 'x' by 3 in GF(2^8)
+    // muliplying 'x' by 3 in GF(2^8)
 #define SSE2NEON_AES_F3(x) (SSE2NEON_AES_F2(x) ^ x)
 #define SSE2NEON_AES_U0(p) \
     SSE2NEON_AES_B2W(SSE2NEON_AES_F2(p), p, p, SSE2NEON_AES_F3(p))
@@ -9175,7 +9175,7 @@ FORCE_INLINE void _sse2neon_mm_set_denormals_zero_mode(unsigned int flag)
 #if defined(__aarch64__) || defined(_M_ARM64)
     _sse2neon_set_fpcr(r.value);
 #else
-    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r));        /* write */
+    __asm__ __volatile__("vmsr FPSCR, %0" ::"r"(r)); /* write */
 #endif
 }
 
diff --git a/tests/impl.cpp b/tests/impl.cpp
index 6934d7d3..d28b4468 100644
--- a/tests/impl.cpp
+++ b/tests/impl.cpp
@@ -2816,17 +2816,17 @@ result_t test_mm_shuffle_pi16(const SSE2NEONTestImpl &impl, uint32_t iter)
     const int16_t *_a = (const int16_t *) impl.mTestIntPointer1;
     __m64 a;
     __m64 d;
-    int16_t _d[4];                                   
-#define TEST_IMPL(IDX)                                    \
-    a = load_m64(_a);                                     \
-    d = _mm_shuffle_pi16(a, IDX);                         \
-                                                          \
+    int16_t _d[4];
+#define TEST_IMPL(IDX)                               \
+    a = load_m64(_a);                                \
+    d = _mm_shuffle_pi16(a, IDX);                    \
+                                                     \
     _d[0] = _a[IDX & 0x3];                           \
     _d[1] = _a[(IDX >> 2) & 0x3];                    \
     _d[2] = _a[(IDX >> 4) & 0x3];                    \
     _d[3] = _a[(IDX >> 6) & 0x3];                    \
     if (VALIDATE_INT16_M64(d, _d) != TEST_SUCCESS) { \
-        return TEST_FAIL;                                 \
+        return TEST_FAIL;                            \
     }
 
     IMM_256_ITER
@@ -5846,7 +5846,7 @@ result_t test_mm_shuffle_epi32(const SSE2NEONTestImpl &impl, uint32_t iter)
 
 #define TEST_IMPL(IDX)                  \
     int32_t d##IDX[4];                  \
-    d##IDX[0] = _a[((IDX) &0x3)];       \
+    d##IDX[0] = _a[((IDX) & 0x3)];      \
     d##IDX[1] = _a[((IDX >> 2) & 0x3)]; \
     d##IDX[2] = _a[((IDX >> 4) & 0x3)]; \
     d##IDX[3] = _a[((IDX >> 6) & 0x3)]; \
@@ -5911,31 +5911,35 @@ result_t test_mm_shufflehi_epi16(const SSE2NEONTestImpl &impl, uint32_t iter)
 
 result_t test_mm_shufflelo_epi16(const SSE2NEONTestImpl &impl, uint32_t iter)
 {
+#if (__GNUC__ == 8 && __GNUC_MINOR__ == 3)
+    return TEST_UNIMPL;
+#else
     const int16_t *_a = (const int16_t *) impl.mTestIntPointer1;
     __m128i a, c;
-
-#define TEST_IMPL(IDX)                                                       \
-    int16_t d##IDX[8];                                                       \
-    d##IDX[0] = (int16_t) (((const int64_t *) _a)[0] >> ((IDX & 0x3) * 16)); \
-    d##IDX[1] =                                                              \
-        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 2) & 0x3) * 16));  \
-    d##IDX[2] =                                                              \
-        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 4) & 0x3) * 16));  \
-    d##IDX[3] =                                                              \
-        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 6) & 0x3) * 16));  \
-    d##IDX[4] = _a[4];                                                       \
-    d##IDX[5] = _a[5];                                                       \
-    d##IDX[6] = _a[6];                                                       \
-    d##IDX[7] = _a[7];                                                       \
-                                                                             \
-    a = load_m128i(_a);                                                      \
-    c = _mm_shufflelo_epi16(a, IDX);                                         \
-                                                                             \
-    CHECK_RESULT(VALIDATE_INT16_M128(c, d##IDX))
+    int16_t _d[8];
+
+#define TEST_IMPL(IDX)                                                      \
+    _d[0] = (int16_t) (((const int64_t *) _a)[0] >> ((IDX & 0x3) * 16));    \
+    _d[1] =                                                                 \
+        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 2) & 0x3) * 16)); \
+    _d[2] =                                                                 \
+        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 4) & 0x3) * 16)); \
+    _d[3] =                                                                 \
+        (int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 6) & 0x3) * 16)); \
+    _d[4] = _a[4];                                                          \
+    _d[5] = _a[5];                                                          \
+    _d[6] = _a[6];                                                          \
+    _d[7] = _a[7];                                                          \
+                                                                            \
+    a = load_m128i(_a);                                                     \
+    c = _mm_shufflelo_epi16(a, IDX);                                        \
+                                                                            \
+    CHECK_RESULT(VALIDATE_INT16_M128(c, _d))
 
     IMM_256_ITER
 #undef TEST_IMPL
     return TEST_SUCCESS;
+#endif
 }
 
 result_t test_mm_sll_epi16(const SSE2NEONTestImpl &impl, uint32_t iter)