Optimize double comparison

When using ZEND_NORMALIZE_BOOL(a - b) where a and b are doubles, this
generates the following instruction sequence on x64:
subsd   xmm0, xmm1
pxor    xmm1, xmm1
comisd  xmm0, xmm1
...

whereas if we use ZEND_THREEWAY_COMPARE we get two instructions less:
ucomisd xmm0, xmm1

The only difference is that the threeway compare uses *u*comisd instead
of comisd. The difference is that it will cause a FP signal if a
signaling NAN is used, but as far as I'm aware this doesn't matter for
our use case.

Author: nielsdos

Zend/zend_operators.c

@@ -2109,7 +2109,7 @@ ZEND_API int ZEND_FASTCALL numeric_compare_function(zval *op1, zval *op2) /* {{{
 	d1 = zval_get_double(op1);
 	d2 = zval_get_double(op2);
 
-	return ZEND_NORMALIZE_BOOL(d1 - d2);
+	return ZEND_THREEWAY_COMPARE(d1, d2);
 }
 /* }}} */
 
@@ -2131,8 +2131,7 @@ static int compare_long_to_string(zend_long lval, zend_string *str) /* {{{ */
 	}
 
 	if (type == IS_DOUBLE) {
-		double diff = (double) lval - str_dval;
-		return ZEND_NORMALIZE_BOOL(diff);
+		return ZEND_THREEWAY_COMPARE((double) lval, str_dval);
 	}
 
 	zend_string *lval_as_str = zend_long_to_str(lval);
@@ -2150,15 +2149,11 @@ static int compare_double_to_string(double dval, zend_string *str) /* {{{ */
 	uint8_t type = is_numeric_string(ZSTR_VAL(str), ZSTR_LEN(str), &str_lval, &str_dval, 0);
 
 	if (type == IS_LONG) {
-		double diff = dval - (double) str_lval;
-		return ZEND_NORMALIZE_BOOL(diff);
+		return ZEND_THREEWAY_COMPARE(dval, (double) str_lval);
 	}
 
 	if (type == IS_DOUBLE) {
-		if (dval == str_dval) {
-			return 0;
-		}
-		return ZEND_NORMALIZE_BOOL(dval - str_dval);
+		return ZEND_THREEWAY_COMPARE(dval, str_dval);
 	}
 
 	zend_string *dval_as_str = zend_double_to_str(dval);
@@ -2225,17 +2220,13 @@ static inline int ZEND_FASTCALL zend_compare_fast(zval *op1, zval *op2, bool con
 			return Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0);
 
 		case TYPE_PAIR(IS_DOUBLE, IS_LONG):
-			return ZEND_NORMALIZE_BOOL(Z_DVAL_P(op1) - (double)Z_LVAL_P(op2));
+			return ZEND_THREEWAY_COMPARE(Z_DVAL_P(op1), (double)Z_LVAL_P(op2));
 
 		case TYPE_PAIR(IS_LONG, IS_DOUBLE):
-			return ZEND_NORMALIZE_BOOL((double)Z_LVAL_P(op1) - Z_DVAL_P(op2));
+			return ZEND_THREEWAY_COMPARE((double)Z_LVAL_P(op1), Z_DVAL_P(op2));
 
 		case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
-			if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) {
-				return 0;
-			} else {
-				return ZEND_NORMALIZE_BOOL(Z_DVAL_P(op1) - Z_DVAL_P(op2));
-			}
+			return ZEND_THREEWAY_COMPARE(Z_DVAL_P(op1), Z_DVAL_P(op2));
 
 		case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
 			return zend_compare_arrays(op1, op2);
@@ -3205,8 +3196,7 @@ ZEND_API int ZEND_FASTCALL zendi_smart_strcmp(zend_string *s1, zend_string *s2)
 				 * so a numeric comparison would be inaccurate */
 				goto string_cmp;
 			}
-			dval1 = dval1 - dval2;
-			return ZEND_NORMALIZE_BOOL(dval1);
+			return ZEND_THREEWAY_COMPARE(dval1, dval2);
 		} else { /* they both have to be long's */
 			return lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0);
 		}