ext/bcmath: optimized divmod() and mod() take 2

ext/bcmath/config.m4

@@ -10,7 +10,6 @@ if test "$PHP_BCMATH" != "no"; then
       libbcmath/src/compare.c
       libbcmath/src/convert.c
       libbcmath/src/div.c
-      libbcmath/src/divmod.c
       libbcmath/src/doaddsub.c
       libbcmath/src/floor_or_ceil.c
       libbcmath/src/long2num.c

ext/bcmath/config.w32

@@ -5,7 +5,7 @@ ARG_ENABLE("bcmath", "bc style precision math functions", "yes");
 if (PHP_BCMATH == "yes") {
 	EXTENSION("bcmath", "bcmath.c",	null, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
 	ADD_SOURCES("ext/bcmath/libbcmath/src", "add.c div.c init.c neg.c \
-		raisemod.c sub.c compare.c divmod.c int2num.c long2num.c \
+		raisemod.c sub.c compare.c int2num.c long2num.c \
 		num2long.c recmul.c sqrt.c zero.c doaddsub.c \
 		floor_or_ceil.c nearzero.c num2str.c raise.c rmzero.c str2num.c \
 		round.c convert.c", "bcmath");

ext/bcmath/libbcmath/src/bcmath.h

@@ -147,11 +147,7 @@ bc_num bc_multiply(bc_num n1, bc_num n2, size_t scale);
 	*(result) = mul_ex;                             \
 } while (0)
 
-bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, size_t scale);
-
-bool bc_modulo(bc_num num1, bc_num num2, bc_num *resul, size_t scale);
-
-bool bc_divmod(bc_num num1, bc_num num2, bc_num *quo, bc_num *rem, size_t scale);
+bool bc_divide_ex(bc_num numerator, bc_num divisor, bc_num *quot, bc_num *rem, size_t scale, bool use_quot, bool use_rem);
 
 bc_num bc_floor_or_ceil(bc_num num, bool is_floor);
 
@@ -188,4 +184,9 @@ bool bc_sqrt(bc_num *num, size_t scale);
 #define bc_free_num(num)					_bc_free_num_ex((num), 0)
 #define bc_num2str(num)						bc_num2str_ex((num), (num->n_scale))
 
+/* div and mod */
+#define bc_divide(n1, n2, quot, scale)		bc_divide_ex((n1), (n2), (quot), NULL, (scale), true, false)
+#define bc_modulo(n1, n2, rem, scale) 		bc_divide_ex((n1), (n2), NULL, (rem), (scale), false, true)
+#define bc_divmod(n1, n2, quot, rem, scale)	bc_divide_ex((n1), (n2), (quot), (rem), (scale), true, true)
+
 #endif

ext/bcmath/libbcmath/src/convert.h

@@ -111,4 +111,30 @@ static inline void bc_convert_vector_to_char(const BC_VECTOR *vector, char *nptr
 	}
 }
 
+static inline void bc_convert_vector_to_char_with_skip(const BC_VECTOR *vector, char *nptr, char *nend, size_t arr_size, size_t skip)
+{
+	/* bulk skip */
+	size_t array_skip = skip / BC_VECTOR_SIZE;
+	arr_size -= array_skip;
+	vector += array_skip;
+
+	/* skip */
+	skip %= BC_VECTOR_SIZE;
+	if (skip > 0) {
+		BC_VECTOR current_vector = *vector;
+		current_vector /= BC_POW_10_LUT[skip];
+		size_t write_size = MIN(nend - nptr + 1, BC_VECTOR_SIZE - skip);
+		for (size_t i = 0; i < write_size; i++) {
+			*nend-- = current_vector % BASE;
+			current_vector /= BASE;
+		}
+		vector++;
+		arr_size--;
+	}
+
+	if (arr_size > 0) {
+		bc_convert_vector_to_char(vector, nptr, nend, arr_size);
+	}
+}
+
 #endif

ext/bcmath/libbcmath/src/div.c

@@ -61,6 +61,7 @@ static inline void bc_fast_div(
 	}
 	/* last */
 	quot_vectors[0] = numerator_vectors[0] / divisor_vector;
+	numerator_vectors[0] -= divisor_vector * quot_vectors[0];
 }
 
 /*
@@ -248,12 +249,15 @@ static inline void bc_standard_div(
 		div_carry = numerator_vectors[numerator_top_index - i];
 		numerator_vectors[numerator_top_index - i] = 0;
 	}
+	numerator_vectors[numerator_top_index - quot_arr_size + 1] = div_carry;
 }
 
 static void bc_do_div(
 	const char *numerator, size_t numerator_size, size_t numerator_readable_size,
 	const char *divisor, size_t divisor_size,
-	bc_num *quot, size_t quot_size
+	bc_num *quot, size_t quot_size,
+	bc_num *rem, size_t rem_over_size, size_t rem_write_size,
+	bool use_quot, bool use_rem
 ) {
 	size_t numerator_arr_size = BC_ARR_SIZE_FROM_LEN(numerator_size);
 	size_t divisor_arr_size = BC_ARR_SIZE_FROM_LEN(divisor_size);
@@ -290,57 +294,134 @@ static void bc_do_div(
 	}
 
 	/* Convert to bc_num */
-	char *qptr = (*quot)->n_value;
-	char *qend = qptr + (*quot)->n_len + (*quot)->n_scale - 1;
+	if (use_quot) {
+		char *qptr = (*quot)->n_value;
+		char *qend = qptr + (*quot)->n_len + (*quot)->n_scale - 1;
+		bc_convert_vector_to_char(quot_vectors, qptr, qend, quot_real_arr_size);
+	}
+	if (use_rem) {
+		char *rptr = (*rem)->n_value;
+		char *rend = rptr + rem_write_size - 1;
+
+		size_t rem_arr_size = (rem_write_size + rem_over_size + BC_VECTOR_SIZE - 1) / BC_VECTOR_SIZE;
+		if (UNEXPECTED(rem_arr_size > numerator_arr_size)) {
+			/* If numerator_arr_size is exceeded because the integer part is zero */
+			rem_arr_size = numerator_arr_size;
+			*rptr = 0;
+		}
+		BC_VECTOR *rem_vectors = numerator_vectors;
 
-	bc_convert_vector_to_char(quot_vectors, qptr, qend, quot_real_arr_size);
+		if (rem_over_size > 0) {
+			bc_convert_vector_to_char_with_skip(rem_vectors, rptr, rend, rem_arr_size, rem_over_size);
+		} else {
+			bc_convert_vector_to_char(rem_vectors, rptr, rend, rem_arr_size);
+		}
+	}
 
 	if (allocation_arr_size > BC_STACK_VECTOR_SIZE) {
 		efree(numerator_vectors);
 	}
 }
 
-static inline void bc_divide_by_one(bc_num numerator, bc_num *quot, size_t quot_scale)
+static inline void bc_divide_copy_numerator(bc_num numerator, bc_num *num, size_t scale)
 {
-	quot_scale = MIN(numerator->n_scale, quot_scale);
-	*quot = bc_new_num_nonzeroed(numerator->n_len, quot_scale);
-	char *qptr = (*quot)->n_value;
-	memcpy(qptr, numerator->n_value, numerator->n_len + quot_scale);
+	scale = MIN(numerator->n_scale, scale);
+	*num = bc_new_num_nonzeroed(numerator->n_len, scale);
+	memcpy((*num)->n_value, numerator->n_value, numerator->n_len + scale);
 }
 
-static inline void bc_divide_by_pow_10(
-	const char *numeratorptr, size_t numerator_readable_size, bc_num *quot, size_t quot_size, size_t quot_scale)
+static inline void bc_divide_by_one(
+	bc_num numerator, bc_num divisor, bc_num *quot, bc_num *rem,
+	size_t quot_scale, size_t rem_scale, bool use_quot, bool use_rem)
 {
-	char *qptr = (*quot)->n_value;
-	for (size_t i = quot_size; i <= quot_scale; i++) {
-		*qptr++ = 0;
+	if (use_quot) {
+		bc_divide_copy_numerator(numerator, quot, quot_scale);
+		(*quot)->n_sign = numerator->n_sign == divisor->n_sign ? PLUS : MINUS;
 	}
+	if (use_rem) {
+		/* When dividing by 1, the integer part of rem is always 0. */
+		rem_scale = MIN(numerator->n_scale, rem_scale);
+		if (rem_scale == 0) {
+			*rem = bc_copy_num(BCG(_zero_));
+		} else {
+			*rem = bc_new_num_nonzeroed(1, rem_scale); /* 1 is for 0 */
+			(*rem)->n_value[0] = 0;
+			/* copy fractional part */
+			memcpy((*rem)->n_value + 1, numerator->n_value + numerator->n_len, rem_scale);
+			if (bc_is_zero(*rem)) {
+				(*rem)->n_sign = PLUS;
+				(*rem)->n_scale = 0;
+			} else {
+				(*rem)->n_sign = numerator->n_sign;
+			}
+		}
+	}
+}
 
-	size_t numerator_use_size = quot_size > numerator_readable_size ? numerator_readable_size : quot_size;
-	memcpy(qptr, numeratorptr, numerator_use_size);
-	qptr += numerator_use_size;
-
-	if (numerator_use_size < (*quot)->n_len) {
-		/* e.g. 12.3 / 0.01 <=> 1230  */
-		for (size_t i = numerator_use_size; i < (*quot)->n_len; i++) {
+static inline void bc_divide_by_pow_10(
+	const char *numeratorptr, size_t numerator_readable_size, size_t numerator_leading_zeros,
+	bc_num *quot, size_t quot_size, size_t quot_scale, bool use_quot,
+	bc_num *rem, size_t rem_size, bool use_rem,
+	size_t numerator_rem_len_diff)
+{
+	if (use_quot) {
+		char *qptr = (*quot)->n_value;
+		for (size_t i = quot_size; i <= quot_scale; i++) {
 			*qptr++ = 0;
 		}
-		(*quot)->n_scale = 0;
-	} else {
-		char *qend = (*quot)->n_value + (*quot)->n_len + (*quot)->n_scale;
-		(*quot)->n_scale -= qend - qptr;
+
+		size_t numerator_use_size = quot_size > numerator_readable_size ? numerator_readable_size : quot_size;
+		memcpy(qptr, numeratorptr, numerator_use_size);
+		qptr += numerator_use_size;
+
+		if (numerator_use_size < (*quot)->n_len) {
+			/* e.g. 12.3 / 0.01 <=> 1230  */
+			for (size_t i = numerator_use_size; i < (*quot)->n_len; i++) {
+				*qptr++ = 0;
+			}
+			(*quot)->n_scale = 0;
+		} else {
+			char *qend = (*quot)->n_value + (*quot)->n_len + (*quot)->n_scale;
+			(*quot)->n_scale -= qend - qptr;
+		}
+	}
+	if (use_rem) {
+		size_t rem_leading_zeros = numerator_leading_zeros + quot_size - numerator_rem_len_diff;
+		if (rem_size <= rem_leading_zeros) {
+			bc_free_num(rem);
+			*rem = bc_copy_num(BCG(_zero_));
+			return;
+		}
+		/* The values after this have already been copied, so just need to set them to 0. */
+		for (size_t i = 0; i < rem_leading_zeros; i++) {
+			(*rem)->n_value[i] = 0;
+		}
+		_bc_rm_leading_zeros(*rem);
+		if (bc_is_zero(*rem)) {
+			(*rem)->n_sign = PLUS;
+			(*rem)->n_scale = 0;
+		}
 	}
 }
 
-bool bc_divide(bc_num numerator, bc_num divisor, bc_num *quot, size_t scale)
+bool bc_divide_ex(bc_num numerator, bc_num divisor, bc_num *quot, bc_num *rem, size_t scale, bool use_quot, bool use_rem)
 {
 	/* divide by zero */
 	if (bc_is_zero(divisor)) {
 		return false;
 	}
 
-	bc_free_num(quot);
-	size_t quot_scale = scale;
+	size_t quot_scale = 0;
+	size_t rem_scale = 0;
+	if (use_quot) {
+		bc_free_num(quot);
+	}
+	if (use_rem) {
+		bc_free_num(rem);
+		rem_scale = scale;
+	} else {
+		quot_scale = scale;
+	}
 
 	/* If numerator is zero, the quotient is always zero. */
 	if (bc_is_zero(numerator)) {
@@ -349,8 +430,7 @@ bool bc_divide(bc_num numerator, bc_num divisor, bc_num *quot, size_t scale)
 
 	/* If divisor is 1 / -1, the quotient's n_value is equal to numerator's n_value. */
 	if (_bc_do_compare(divisor, BCG(_one_), divisor->n_scale, false) == BCMATH_EQUAL) {
-		bc_divide_by_one(numerator, quot, quot_scale);
-		(*quot)->n_sign = numerator->n_sign == divisor->n_sign ? PLUS : MINUS;
+		bc_divide_by_one(numerator, divisor, quot, rem, quot_scale, rem_scale, use_quot, use_rem);
 		return true;
 	}
 
@@ -372,10 +452,12 @@ bool bc_divide(bc_num numerator, bc_num divisor, bc_num *quot, size_t scale)
 	numerator_size -= numerator_leading_zeros;
 
 	/* check and remove divisor leading zeros */
+	size_t divisor_leading_zeros = 0;
 	while (*divisorptr == 0) {
 		divisorptr++;
-		divisor_size--;
+		divisor_leading_zeros++;
 	}
+	divisor_size -= divisor_leading_zeros;
 
 	if (divisor_size > numerator_size) {
 		goto quot_zero;
@@ -393,39 +475,102 @@ bool bc_divide(bc_num numerator, bc_num divisor, bc_num *quot, size_t scale)
 	numerator_size -= divisor_trailing_zeros;
 
 	size_t quot_size = numerator_size - divisor_size + 1; /* numerator_size >= divisor_size */
-	if (quot_size > quot_scale) {
-		*quot = bc_new_num_nonzeroed(quot_size - quot_scale, quot_scale);
-	} else {
-		*quot = bc_new_num_nonzeroed(1, quot_scale); /* 1 is for 0 */
+	if (use_quot) {
+		if (quot_size > quot_scale) {
+			*quot = bc_new_num_nonzeroed(quot_size - quot_scale, quot_scale);
+		} else {
+			*quot = bc_new_num_nonzeroed(1, quot_scale); /* 1 is for 0 */
+		}
+		(*quot)->n_sign = numerator->n_sign == divisor->n_sign ? PLUS : MINUS;
+	}
+
+	/**
+	 * If the calculation uses more digits than the scale of rem, writing the vector directly to rem
+	 * will exceed the size, so calculate the excess size in advance.
+	 */
+	size_t rem_over_size = 0;
+
+	/**
+	 * Conversely, there are cases where the vector does not fill the rem size.
+	 * In this case, the size to be written is calculated in advance to determine the start position for writing to rem.
+	 */
+	size_t rem_write_size = 0;
+
+	size_t rem_size = 0;
+	size_t numerator_rem_len_diff = 0;
+	if (use_rem) {
+		size_t divisor_int_size = divisor->n_len > divisor_leading_zeros ? divisor->n_len - divisor_leading_zeros : 0;
+		size_t divisor_frac_size = divisor->n_scale > divisor_trailing_zeros ? divisor->n_scale - divisor_trailing_zeros : 0;
+		rem_scale = MIN(MAX(numerator->n_scale, divisor_frac_size), rem_scale);
+
+		*rem = bc_new_num_nonzeroed(divisor_int_size > 0 ? divisor_int_size : 1, rem_scale); // 1 is for 0
+		(*rem)->n_sign = numerator->n_sign;
+
+		if (divisor_frac_size > rem_scale) {
+			rem_over_size = divisor_frac_size - rem_scale;
+			rem_write_size = (*rem)->n_len + rem_scale;
+		} else {
+			if (divisor_frac_size > 0) {
+				rem_write_size = (*rem)->n_len + divisor_frac_size;
+			} else {
+				/* e.g. 123 % 30 */
+				rem_write_size = (*rem)->n_len - (divisor_trailing_zeros - divisor->n_scale);
+			}
+		}
+
+		rem_size = (*rem)->n_len + (*rem)->n_scale;
+		if (rem_size > rem_write_size) {
+			size_t copy_size = rem_size - rem_write_size;
+			numerator_rem_len_diff = numerator->n_len - (*rem)->n_len;
+			memcpy((*rem)->n_value + rem_write_size, numerator->n_value + rem_write_size + numerator_rem_len_diff, copy_size);
+		}
 	}
 
 	/* Size that can be read from numeratorptr */
 	size_t numerator_readable_size = numerator->n_len + numerator->n_scale - numerator_leading_zeros;
 
 	/* If divisor is 1 here, return the result of adjusting the decimal point position of numerator. */
 	if (divisor_size == 1 && *divisorptr == 1) {
-		bc_divide_by_pow_10(numeratorptr, numerator_readable_size, quot, quot_size, quot_scale);
-		(*quot)->n_sign = numerator->n_sign == divisor->n_sign ? PLUS : MINUS;
+		bc_divide_by_pow_10(
+			numeratorptr, numerator_readable_size, numerator_leading_zeros,
+			quot, quot_size, quot_scale, use_quot,
+			rem, rem_size, use_rem, numerator_rem_len_diff
+		);
 		return true;
 	}
 
 	/* do divide */
 	bc_do_div(
 		numeratorptr, numerator_size, numerator_readable_size,
 		divisorptr, divisor_size,
-		quot, quot_size
+		quot, quot_size,
+		rem, rem_over_size, rem_write_size,
+		use_quot, use_rem
 	);
 
-	_bc_rm_leading_zeros(*quot);
-	if (bc_is_zero(*quot)) {
-		(*quot)->n_sign = PLUS;
-		(*quot)->n_scale = 0;
-	} else {
-		(*quot)->n_sign = numerator->n_sign == divisor->n_sign ? PLUS : MINUS;
+	if (use_quot) {
+		_bc_rm_leading_zeros(*quot);
+		if (bc_is_zero(*quot)) {
+			(*quot)->n_sign = PLUS;
+			(*quot)->n_scale = 0;
+		}
+	}
+	if (use_rem) {
+		_bc_rm_leading_zeros(*rem);
+		if (bc_is_zero(*rem)) {
+			(*rem)->n_sign = PLUS;
+			(*rem)->n_scale = 0;
+		}
 	}
 	return true;
 
 quot_zero:
-	*quot = bc_copy_num(BCG(_zero_));
+	if (use_quot) {
+		*quot = bc_copy_num(BCG(_zero_));
+	}
+	if (use_rem) {
+		bc_divide_copy_numerator(numerator, rem, rem_scale);
+		(*rem)->n_sign = numerator->n_sign;
+	}
 	return true;
 }