Optimize zend scalar comparison helpers

Avoid temporary zend_string allocations in `compare_long_to_string()`
and `compare_double_to_string()` by using stack buffers, and streamline
`zendi_smart_strcmp()` with non-numeric short-circuits plus single-pass
numeric parsing to cut redundant work in general comparisons.

Author: jmarble

Zend/zend_operators.c

@@ -2264,17 +2264,18 @@ static int compare_long_to_string(zend_long lval, zend_string *str) /* {{{ */
 	uint8_t type = is_numeric_string(ZSTR_VAL(str), ZSTR_LEN(str), &str_lval, &str_dval, 0);
 
 	if (type == IS_LONG) {
-		return lval > str_lval ? 1 : lval < str_lval ? -1 : 0;
+		return ZEND_THREEWAY_COMPARE(lval, str_lval);
 	}
 
 	if (type == IS_DOUBLE) {
 		return ZEND_THREEWAY_COMPARE((double) lval, str_dval);
 	}
 
-	zend_string *lval_as_str = zend_long_to_str(lval);
+	char buf[MAX_LENGTH_OF_LONG + 1];
+	char *tmp = zend_print_long_to_buf(buf + sizeof(buf) - 1, lval);
+	size_t tmp_len = buf + sizeof(buf) - 1 - tmp;
 	int cmp_result = zend_binary_strcmp(
-		ZSTR_VAL(lval_as_str), ZSTR_LEN(lval_as_str), ZSTR_VAL(str), ZSTR_LEN(str));
-	zend_string_release(lval_as_str);
+		tmp, tmp_len, ZSTR_VAL(str), ZSTR_LEN(str));
 	return ZEND_NORMALIZE_BOOL(cmp_result);
 }
 /* }}} */
@@ -2295,10 +2296,12 @@ static int compare_double_to_string(double dval, zend_string *str) /* {{{ */
 		return ZEND_THREEWAY_COMPARE(dval, str_dval);
 	}
 
-	zend_string *dval_as_str = zend_double_to_str(dval);
+	char buf[ZEND_DOUBLE_MAX_LENGTH];
+	int precision = (int) EG(precision);
+	zend_gcvt(dval, precision ? precision : 1, '.', 'E', buf);
+	size_t tmp_len = strlen(buf);
 	int cmp_result = zend_binary_strcmp(
-		ZSTR_VAL(dval_as_str), ZSTR_LEN(dval_as_str), ZSTR_VAL(str), ZSTR_LEN(str));
-	zend_string_release(dval_as_str);
+		buf, tmp_len, ZSTR_VAL(str), ZSTR_LEN(str));
 	return ZEND_NORMALIZE_BOOL(cmp_result);
 }
 /* }}} */
@@ -3420,52 +3423,73 @@ ZEND_API bool ZEND_FASTCALL zendi_smart_streq(zend_string *s1, zend_string *s2)
 
 ZEND_API int ZEND_FASTCALL zendi_smart_strcmp(zend_string *s1, zend_string *s2) /* {{{ */
 {
-	uint8_t ret1, ret2;
-	int oflow1, oflow2;
+	uint8_t ret1 = 0, ret2 = 0;
+	int oflow1 = 0, oflow2 = 0;
 	zend_long lval1 = 0, lval2 = 0;
 	double dval1 = 0.0, dval2 = 0.0;
 
-	if ((ret1 = is_numeric_string_ex(s1->val, s1->len, &lval1, &dval1, false, &oflow1, NULL)) &&
-		(ret2 = is_numeric_string_ex(s2->val, s2->len, &lval2, &dval2, false, &oflow2, NULL))) {
+	if ((unsigned char)s1->val[0] > '9' && (unsigned char)s2->val[0] > '9') {
+		goto string_cmp;
+	}
+
+	if (UNEXPECTED(s1->len == 0 || s2->len == 0)) {
+		goto string_cmp;
+	}
+
+	if ((unsigned char)s1->val[0] <= '9') {
+		ret1 = is_numeric_string_ex(s1->val, s1->len, &lval1, &dval1, false, &oflow1, NULL);
+	}
+
+	if (!ret1) {
+		goto string_cmp;
+	}
+
+	ret2 = ((unsigned char)s2->val[0] <= '9')
+		? is_numeric_string_ex(s2->val, s2->len, &lval2, &dval2, false, &oflow2, NULL)
+		: 0;
+
+	if (!ret2) {
+		goto string_cmp;
+	}
+
 #if ZEND_ULONG_MAX == 0xFFFFFFFF
-		if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
-			((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/)
-			|| (oflow1 == -1 && dval1 < -9007199254740991.))) {
+	if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
+		((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/)
+		|| (oflow1 == -1 && dval1 < -9007199254740991.))) {
 #else
-		if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0.) {
+	if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0.) {
 #endif
-			/* both values are integers overflowed to the same side, and the
-			 * double comparison may have resulted in crucial accuracy lost */
+		/* both values are integers overflowed to the same side, and the
+		 * double comparison may have resulted in crucial accuracy lost */
+		goto string_cmp;
+	}
+
+	if ((ret1 == IS_DOUBLE) || (ret2 == IS_DOUBLE)) {
+		if (ret1 != IS_DOUBLE) {
+			if (oflow2) {
+				/* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */
+				return -1 * oflow2;
+			}
+			dval1 = (double) lval1;
+		} else if (ret2 != IS_DOUBLE) {
+			if (oflow1) {
+				return oflow1;
+			}
+			dval2 = (double) lval2;
+		} else if (dval1 == dval2 && !zend_finite(dval1)) {
+			/* Both values overflowed and have the same sign,
+			 * so a numeric comparison would be inaccurate */
 			goto string_cmp;
 		}
-		if ((ret1 == IS_DOUBLE) || (ret2 == IS_DOUBLE)) {
-			if (ret1 != IS_DOUBLE) {
-				if (oflow2) {
-					/* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */
-					return -1 * oflow2;
-				}
-				dval1 = (double) lval1;
-			} else if (ret2 != IS_DOUBLE) {
-				if (oflow1) {
-					return oflow1;
-				}
-				dval2 = (double) lval2;
-			} else if (dval1 == dval2 && !zend_finite(dval1)) {
-				/* Both values overflowed and have the same sign,
-				 * so a numeric comparison would be inaccurate */
-				goto string_cmp;
-			}
-			dval1 = dval1 - dval2;
-			return ZEND_NORMALIZE_BOOL(dval1);
-		} else { /* they both have to be long's */
-			return lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0);
-		}
-	} else {
-		int strcmp_ret;
-string_cmp:
-		strcmp_ret = zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len);
-		return ZEND_NORMALIZE_BOOL(strcmp_ret);
+		return ZEND_THREEWAY_COMPARE(dval1, dval2);
 	}
+
+	return ZEND_THREEWAY_COMPARE(lval1, lval2);
+
+	int strcmp_ret;
+string_cmp:
+	strcmp_ret = zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len);
+	return ZEND_NORMALIZE_BOOL(strcmp_ret);
 }
 /* }}} */