In the arm processor environment, NEON is used to use SIMD.

Author: SakiTakamachi

ext/bcmath/libbcmath/src/convert.c

@@ -17,24 +17,21 @@
 #include "bcmath.h"
 #include "convert.h"
 #include "private.h"
-#ifdef __SSE2__
-# include <emmintrin.h>
-#endif
 
 char *bc_copy_and_toggle_bcd(char *restrict dest, const char *source, const char *source_end)
 {
 	const size_t bulk_shift = SWAR_REPEAT('0');
 
-#ifdef __SSE2__
-	/* SIMD SSE2 bulk shift + copy */
-	__m128i shift_vector = _mm_set1_epi8('0');
-	while (source + sizeof(__m128i) <= source_end) {
-		__m128i bytes = _mm_loadu_si128((const __m128i *) source);
-		bytes = _mm_xor_si128(bytes, shift_vector);
-		_mm_storeu_si128((__m128i *) dest, bytes);
+#ifdef HAVE_BC_SIMD128_T
+	/* SIMD SSE2 of NEON bulk shift + copy */
+	bc_simd_128_t shift_vector = bc_set_8x16('0');
+	while (source + sizeof(bc_simd_128_t) <= source_end) {
+		bc_simd_128_t bytes = bc_load_u128((const bc_simd_128_t *) source);
+		bytes = bc_xor_128(bytes, shift_vector);
+		bc_store_u128((bc_simd_128_t *) dest, bytes);
 
-		source += sizeof(__m128i);
-		dest += sizeof(__m128i);
+		source += sizeof(bc_simd_128_t);
+		dest += sizeof(bc_simd_128_t);
 	}
 #endif
 

ext/bcmath/libbcmath/src/private.h

@@ -69,6 +69,53 @@
 
 #define BC_ARR_SIZE_FROM_LEN(len) (((len) + BC_VECTOR_SIZE - 1) / BC_VECTOR_SIZE)
 
+#ifdef __SSE2__
+# include <emmintrin.h>
+  typedef __m128i bc_simd_128_t;
+# define HAVE_BC_SIMD128_T
+# define bc_set_8x16(x) _mm_set1_epi8(x)
+# define bc_load_u128(ptr) _mm_loadu_si128((const __m128i *) (ptr))
+# define bc_xor_128(a, b) _mm_xor_si128(a, b)
+# define bc_store_u128(ptr, val) _mm_storeu_si128((__m128i *) (ptr), val)
+# define bc_add_8x16(a, b) _mm_add_epi8(a, b)
+# define bc_cmpeq_8x16(a, b) _mm_cmpeq_epi8(a, b)
+# define bc_cmplt_8x16(a, b) _mm_cmplt_epi8(a, b)
+# define bc_movemask_8x16(a) _mm_movemask_epi8(a)
+#elif defined(__aarch64__) || defined(_M_ARM64)
+# include <arm_neon.h>
+  typedef int8x16_t bc_simd_128_t;
+# define HAVE_BC_SIMD128_T
+# define bc_set_8x16(x) vdupq_n_s8(x)
+# define bc_load_u128(ptr) vld1q_s8((const int8_t *) (ptr))
+# define bc_xor_128(a, b) veorq_s8(a, b)
+# define bc_store_u128(ptr, val) vst1q_s8((int8_t *) (ptr), val)
+# define bc_add_8x16(a, b) vaddq_s8(a, b)
+# define bc_cmpeq_8x16(a, b) (vreinterpretq_s8_u8(vceqq_s8(a, b)))
+# define bc_cmplt_8x16(a, b) (vreinterpretq_s8_u8(vcltq_s8(a, b)))
+  static inline int bc_movemask_8x16(int8x16_t vec)
+  {
+	  // bulk shift right by 7
+	  uint8x16_t uvec = vshrq_n_u8(vreinterpretq_u8_s8(vec), 7);
+	  return
+		  (vgetq_lane_u8(uvec,  0) << 0) |
+		  (vgetq_lane_u8(uvec,  1) << 1) |
+		  (vgetq_lane_u8(uvec,  2) << 2) |
+		  (vgetq_lane_u8(uvec,  3) << 3) |
+		  (vgetq_lane_u8(uvec,  4) << 4) |
+		  (vgetq_lane_u8(uvec,  5) << 5) |
+		  (vgetq_lane_u8(uvec,  6) << 6) |
+		  (vgetq_lane_u8(uvec,  7) << 7) |
+		  (vgetq_lane_u8(uvec,  8) << 8) |
+		  (vgetq_lane_u8(uvec,  9) << 9) |
+		  (vgetq_lane_u8(uvec, 10) << 10) |
+		  (vgetq_lane_u8(uvec, 11) << 11) |
+		  (vgetq_lane_u8(uvec, 12) << 12) |
+		  (vgetq_lane_u8(uvec, 13) << 13) |
+		  (vgetq_lane_u8(uvec, 14) << 14) |
+		  (vgetq_lane_u8(uvec, 15) << 15);
+  }
+#endif
+
 /*
  * Adding more than this many times may cause uint32_t/uint64_t to overflow.
  * Typically this is 1844 for 64bit and 42 for 32bit.

ext/bcmath/libbcmath/src/str2num.c

@@ -34,28 +34,25 @@
 #include "private.h"
 #include <stdbool.h>
 #include <stddef.h>
-#ifdef __SSE2__
-# include <emmintrin.h>
-#endif
 
 /* Convert strings to bc numbers.  Base 10 only.*/
 static const char *bc_count_digits(const char *str, const char *end)
 {
 	/* Process in bulk */
-#ifdef __SSE2__
-	const __m128i offset = _mm_set1_epi8((signed char) (SCHAR_MIN - '0'));
+#ifdef HAVE_BC_SIMD128_T
+	const bc_simd_128_t offset = bc_set_8x16((signed char) (SCHAR_MIN - '0'));
 	/* we use the less than comparator, so add 1 */
-	const __m128i threshold = _mm_set1_epi8(SCHAR_MIN + ('9' + 1 - '0'));
+	const bc_simd_128_t threshold = bc_set_8x16(SCHAR_MIN + ('9' + 1 - '0'));
 
-	while (str + sizeof(__m128i) <= end) {
-		__m128i bytes = _mm_loadu_si128((const __m128i *) str);
+	while (str + sizeof(bc_simd_128_t) <= end) {
+		bc_simd_128_t bytes = bc_load_u128((const bc_simd_128_t *) str);
 		/* Wrapping-add the offset to the bytes, such that all bytes below '0' are positive and others are negative.
 		 * More specifically, '0' will be -128 and '9' will be -119. */
-		bytes = _mm_add_epi8(bytes, offset);
+		bytes = bc_add_8x16(bytes, offset);
 		/* Now mark all bytes that are <= '9', i.e. <= -119, i.e. < -118, i.e. the threshold. */
-		bytes = _mm_cmplt_epi8(bytes, threshold);
+		bytes = bc_cmplt_8x16(bytes, threshold);
 
-		int mask = _mm_movemask_epi8(bytes);
+		int mask = bc_movemask_8x16(bytes);
 		if (mask != 0xffff) {
 			/* At least one of the bytes is not within range. Move to the first offending byte. */
 #ifdef PHP_HAVE_BUILTIN_CTZL
@@ -65,7 +62,7 @@ static const char *bc_count_digits(const char *str, const char *end)
 #endif
 		}
 
-		str += sizeof(__m128i);
+		str += sizeof(bc_simd_128_t);
 	}
 #endif
 
@@ -79,19 +76,19 @@ static const char *bc_count_digits(const char *str, const char *end)
 static inline const char *bc_skip_zero_reverse(const char *scanner, const char *stop)
 {
 	/* Check in bulk */
-#ifdef __SSE2__
-	const __m128i c_zero_repeat = _mm_set1_epi8('0');
-	while (scanner - sizeof(__m128i) >= stop) {
-		scanner -= sizeof(__m128i);
-		__m128i bytes = _mm_loadu_si128((const __m128i *) scanner);
+#ifdef HAVE_BC_SIMD128_T
+	const bc_simd_128_t c_zero_repeat = bc_set_8x16('0');
+	while (scanner - sizeof(bc_simd_128_t) >= stop) {
+		scanner -= sizeof(bc_simd_128_t);
+		bc_simd_128_t bytes = bc_load_u128((const bc_simd_128_t *) scanner);
 		/* Checks if all numeric strings are equal to '0'. */
-		bytes = _mm_cmpeq_epi8(bytes, c_zero_repeat);
+		bytes = bc_cmpeq_8x16(bytes, c_zero_repeat);
 
-		int mask = _mm_movemask_epi8(bytes);
+		int mask = bc_movemask_8x16(bytes);
 		/* The probability of having 16 trailing 0s in a row is very low, so we use EXPECTED. */
 		if (EXPECTED(mask != 0xffff)) {
 			/* Move the pointer back and check each character in loop. */
-			scanner += sizeof(__m128i);
+			scanner += sizeof(bc_simd_128_t);
 			break;
 		}
 	}