Improve ZPP weak parsing by returning value directly when possible

Girgias · web-flow · commit b9f64f7afa4e · 2026-05-02T15:37:10.000+01:00
These changes are based on a previous PR by @ndossche to reduce codebloat: #18436 For zend_parse_arg_str_weak() we can return a `zend_string*` directly, as errors can be indicated by a NULL pointer return. For zend_parse_arg_double_weak() we can return a `double` directly, as we can represent ZPP errors via `NAN` as booleans and integers never coerce to NAN. One might think that the string `'NAN'` can be coerced to double `NAN`, however PHP doesn't allow this coercion. And an explicit cast to double via `(float)` of such a string results in 0. For zend_parse_arg_bool_weak() we instead create a new enum zpp_parse_bool_status that represents a tri-state which we return. Allowing us to return the boolean value via the return type instead of using an out pointer.
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -509,35 +509,33 @@ static ZEND_COLD bool zend_null_arg_deprecated(const char *fallback_type, uint32
 	return !EG(exception);
 }
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_weak(const zval *arg, bool *dest, uint32_t arg_num) /* {{{ */
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_weak(const zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (EXPECTED(Z_TYPE_P(arg) <= IS_STRING)) {
 		if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("bool", arg_num)) {
-			return 0;
+			return ZPP_PARSE_BOOL_STATUS_ERROR;
 		}
-		*dest = zend_is_true(arg);
-	} else {
-		return 0;
+		return zend_is_true(arg);
 	}
-	return 1;
+	return ZPP_PARSE_BOOL_STATUS_ERROR;
 }
 /* }}} */
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_slow(const zval *arg, bool *dest, uint32_t arg_num) /* {{{ */
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_slow(const zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {
-		return 0;
+		return ZPP_PARSE_BOOL_STATUS_ERROR;
 	}
-	return zend_parse_arg_bool_weak(arg, dest, arg_num);
+	return zend_parse_arg_bool_weak(arg, arg_num);
 }
 /* }}} */
 
-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval *arg, bool *dest, uint32_t arg_num)
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval *arg, uint32_t arg_num)
 {
 	if (UNEXPECTED(ZEND_FLF_ARG_USES_STRICT_TYPES())) {
-		return 0;
+		return ZPP_PARSE_BOOL_STATUS_ERROR;
 	}
-	return zend_parse_arg_bool_weak(arg, dest, arg_num);
+	return zend_parse_arg_bool_weak(arg, arg_num);
 }
 
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_weak(const zval *arg, zend_long *dest, uint32_t arg_num) /* {{{ */
@@ -624,44 +622,46 @@ ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_long_slow(const zval *arg, zend_l
 	return zend_parse_arg_long_weak(arg, dest, arg_num);
 }
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_weak(const zval *arg, double *dest, uint32_t arg_num) /* {{{ */
+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_weak(const zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
-		*dest = (double)Z_LVAL_P(arg);
+		return (double)Z_LVAL_P(arg);
 	} else if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
 		zend_long l;
+		double dval;
 		uint8_t type;
 
-		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, dest)) != IS_DOUBLE)) {
+		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, &dval)) != IS_DOUBLE)) {
 			if (EXPECTED(type != 0)) {
-				*dest = (double)(l);
+				return (double)(l);
 			} else {
-				return 0;
+				return NAN;
 			}
+		} else {
+			return dval;
 		}
 	} else if (EXPECTED(Z_TYPE_P(arg) < IS_TRUE)) {
 		if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("float", arg_num)) {
-			return 0;
+			return NAN;
 		}
-		*dest = 0.0;
+		return 0.0;
 	} else if (EXPECTED(Z_TYPE_P(arg) == IS_TRUE)) {
-		*dest = 1.0;
+		return 1.0;
 	} else {
-		return 0;
+		return NAN;
 	}
-	return 1;
 }
 /* }}} */
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_slow(const zval *arg, double *dest, uint32_t arg_num) /* {{{ */
+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_slow(const zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
 		/* SSTH Exception: IS_LONG may be accepted instead as IS_DOUBLE */
-		*dest = (double)Z_LVAL_P(arg);
+		return (double)Z_LVAL_P(arg);
 	} else if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {
-		return 0;
+		return NAN;
 	}
-	return zend_parse_arg_double_weak(arg, dest, arg_num);
+	return zend_parse_arg_double_weak(arg, arg_num);
 }
 /* }}} */
 
@@ -728,58 +728,58 @@ ZEND_API bool ZEND_FASTCALL zend_parse_arg_number_or_str_slow(zval *arg, zval **
 	return true;
 }
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, zend_string **dest, uint32_t arg_num) /* {{{ */
+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (EXPECTED(Z_TYPE_P(arg) < IS_STRING)) {
 		if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("string", arg_num)) {
-			return 0;
+			return NULL;
 		}
 		convert_to_string(arg);
-		*dest = Z_STR_P(arg);
+		return Z_STR_P(arg);
 	} else if (UNEXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
 		zend_object *zobj = Z_OBJ_P(arg);
 		zval obj;
 		if (zobj->handlers->cast_object(zobj, &obj, IS_STRING) == SUCCESS) {
 			OBJ_RELEASE(zobj);
 			ZVAL_COPY_VALUE(arg, &obj);
-			*dest = Z_STR_P(arg);
-			return 1;
+			return Z_STR_P(arg);
 		}
-		return 0;
+		return NULL;
 	} else {
-		return 0;
+		return NULL;
 	}
-	return 1;
 }
 /* }}} */
 
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, zend_string **dest, uint32_t arg_num) /* {{{ */
+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, uint32_t arg_num) /* {{{ */
 {
 	if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {
-		return 0;
+		return NULL;
 	}
-	return zend_parse_arg_str_weak(arg, dest, arg_num);
+	return zend_parse_arg_str_weak(arg, arg_num);
 }
 /* }}} */
 
-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval *arg, zend_string **dest, uint32_t arg_num)
+ZEND_API zend_string* ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval *arg, uint32_t arg_num)
 {
 	if (UNEXPECTED(ZEND_FLF_ARG_USES_STRICT_TYPES())) {
-		return 0;
+		return NULL;
 	}
-	return zend_parse_arg_str_weak(arg, dest, arg_num);
+	return zend_parse_arg_str_weak(arg, arg_num);
 }
 
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_or_long_slow(zval *arg, zend_string **dest_str, zend_long *dest_long, uint32_t arg_num) /* {{{ */
 {
+	zend_string *str;
 	if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {
 		return 0;
 	}
 	if (zend_parse_arg_long_weak(arg, dest_long, arg_num)) {
 		*dest_str = NULL;
 		return 1;
-	} else if (zend_parse_arg_str_weak(arg, dest_str, arg_num)) {
+	} else if ((str = zend_parse_arg_str_weak(arg, arg_num)) != NULL) {
 		*dest_long = 0;
+		*dest_str = str;
 		return 1;
 	} else {
 		return 0;
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
@@ -2179,21 +2179,27 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string
 
 /* Inlined implementations shared by new and old parameter parsing APIs */
 
+typedef enum zpp_parse_bool_status {
+	ZPP_PARSE_BOOL_STATUS_FALSE = 0,
+	ZPP_PARSE_BOOL_STATUS_TRUE = 1,
+	ZPP_PARSE_BOOL_STATUS_ERROR = 2,
+} zpp_parse_bool_status;
+
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **pce, uint32_t num, bool check_null);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_slow(const zval *arg, bool *dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_weak(const zval *arg, bool *dest, uint32_t arg_num);
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_slow(const zval *arg, uint32_t arg_num);
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_weak(const zval *arg, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_slow(const zval *arg, zend_long *dest, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_weak(const zval *arg, zend_long *dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_slow(const zval *arg, double *dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_weak(const zval *arg, double *dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, zend_string **dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, zend_string **dest, uint32_t arg_num);
+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_slow(const zval *arg, uint32_t arg_num);
+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_weak(const zval *arg, uint32_t arg_num);
+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, uint32_t arg_num);
+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_number_slow(zval *arg, zval **dest, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_number_or_str_slow(zval *arg, zval **dest, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_or_long_slow(zval *arg, zend_string **dest_str, zend_long *dest_long, uint32_t arg_num);
 
-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval *arg, bool *dest, uint32_t arg_num);
-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval *arg, zend_string **dest, uint32_t arg_num);
+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval *arg, uint32_t arg_num);
+ZEND_API zend_string* ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval *arg, uint32_t arg_num);
 ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_long_slow(const zval *arg, zend_long *dest, uint32_t arg_num);
 
 static zend_always_inline bool zend_parse_arg_bool_ex(const zval *arg, bool *dest, bool *is_null, bool check_null, uint32_t arg_num, bool frameless)
@@ -2209,11 +2215,16 @@ static zend_always_inline bool zend_parse_arg_bool_ex(const zval *arg, bool *des
 		*is_null = 1;
 		*dest = 0;
 	} else {
+		zpp_parse_bool_status result;
 		if (frameless) {
-			return zend_flf_parse_arg_bool_slow(arg, dest, arg_num);
+			result = zend_flf_parse_arg_bool_slow(arg, arg_num);
 		} else {
-			return zend_parse_arg_bool_slow(arg, dest, arg_num);
+			result = zend_parse_arg_bool_slow(arg, arg_num);
+		}
+		if (UNEXPECTED(result == ZPP_PARSE_BOOL_STATUS_ERROR)) {
+			return false;
 		}
+		*dest = result;
 	}
 	return 1;
 }
@@ -2259,7 +2270,8 @@ static zend_always_inline bool zend_parse_arg_double(const zval *arg, double *de
 		*is_null = 1;
 		*dest = 0.0;
 	} else {
-		return zend_parse_arg_double_slow(arg, dest, arg_num);
+		*dest = zend_parse_arg_double_slow(arg, arg_num);
+		return !zend_isnan(*dest);
 	}
 	return 1;
 }
@@ -2296,12 +2308,13 @@ static zend_always_inline bool zend_parse_arg_str_ex(zval *arg, zend_string **de
 		*dest = NULL;
 	} else {
 		if (frameless) {
-			return zend_flf_parse_arg_str_slow(arg, dest, arg_num);
+			*dest = zend_flf_parse_arg_str_slow(arg, arg_num);
 		} else {
-			return zend_parse_arg_str_slow(arg, dest, arg_num);
+			*dest = zend_parse_arg_str_slow(arg, arg_num);
 		}
+		return *dest != NULL;
 	}
-	return 1;
+	return true;
 }
 
 static zend_always_inline bool zend_parse_arg_str(zval *arg, zend_string **dest, bool check_null, uint32_t arg_num)
@@ -2532,7 +2545,8 @@ static zend_always_inline bool zend_parse_arg_array_ht_or_str(
 		*dest_str = NULL;
 	} else {
 		*dest_ht = NULL;
-		return zend_parse_arg_str_slow(arg, dest_str, arg_num);
+		*dest_str = zend_parse_arg_str_slow(arg, arg_num);
+		return *dest_str != NULL;
 	}
 	return 1;
 }
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -733,8 +733,6 @@ static bool zend_verify_weak_scalar_type_hint(uint32_t type_mask, zval *arg)
 {
 	zend_long lval;
 	double dval;
-	zend_string *str;
-	bool bval;
 
 	/* Type preference order: int -> float -> string -> bool */
 	if (type_mask & MAY_BE_LONG) {
@@ -760,16 +758,23 @@ static bool zend_verify_weak_scalar_type_hint(uint32_t type_mask, zval *arg)
 			return false;
 		}
 	}
-	if ((type_mask & MAY_BE_DOUBLE) && zend_parse_arg_double_weak(arg, &dval, 0)) {
-		zval_ptr_dtor(arg);
-		ZVAL_DOUBLE(arg, dval);
-		return true;
+	if (type_mask & MAY_BE_DOUBLE) {
+		dval = zend_parse_arg_double_weak(arg, 0);
+		if (EXPECTED(!zend_isnan(dval))) {
+			zval_ptr_dtor(arg);
+			ZVAL_DOUBLE(arg, dval);
+			return true;
+		}
 	}
-	if ((type_mask & MAY_BE_STRING) && zend_parse_arg_str_weak(arg, &str, 0)) {
+	if ((type_mask & MAY_BE_STRING) && zend_parse_arg_str_weak(arg, 0)) {
 		/* on success "arg" is converted to IS_STRING */
 		return true;
 	}
-	if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL && zend_parse_arg_bool_weak(arg, &bval, 0)) {
+	if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL) {
+		zpp_parse_bool_status bval = zend_parse_arg_bool_weak(arg, 0);
+		if (UNEXPECTED(bval == ZPP_PARSE_BOOL_STATUS_ERROR)) {
+			return false;
+		}
 		zval_ptr_dtor(arg);
 		ZVAL_BOOL(arg, bval);
 		return true;
@@ -793,21 +798,19 @@ static bool can_convert_to_string(const zval *zv) {
 static bool zend_verify_weak_scalar_type_hint_no_sideeffect(uint32_t type_mask, const zval *arg)
 {
 	zend_long lval;
-	double dval;
-	bool bval;
 
 	/* Pass (uint32_t)-1 as arg_num to indicate to ZPP not to emit any deprecation notice,
 	 * this is needed because the version with side effects also uses 0 (e.g. for typed properties) */
 	if ((type_mask & MAY_BE_LONG) && zend_parse_arg_long_weak(arg, &lval, (uint32_t)-1)) {
 		return true;
 	}
-	if ((type_mask & MAY_BE_DOUBLE) && zend_parse_arg_double_weak(arg, &dval, (uint32_t)-1)) {
+	if ((type_mask & MAY_BE_DOUBLE) && !zend_isnan(zend_parse_arg_double_weak(arg, (uint32_t)-1))) {
 		return true;
 	}
 	if ((type_mask & MAY_BE_STRING) && can_convert_to_string(arg)) {
 		return true;
 	}
-	if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL && zend_parse_arg_bool_weak(arg, &bval, (uint32_t)-1)) {
+	if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL && zend_parse_arg_bool_weak(arg, (uint32_t)-1) != ZPP_PARSE_BOOL_STATUS_ERROR) {
 		return true;
 	}
 	return false;
diff --git a/Zend/zend_frameless_function.h b/Zend/zend_frameless_function.h
@@ -64,7 +64,7 @@
 		dest_ht = NULL; \
 		ZVAL_COPY(&str_tmp, arg ## arg_num); \
 		arg ## arg_num = &str_tmp; \
-		if (!zend_flf_parse_arg_str_slow(arg ## arg_num, &dest_str, arg_num)) { \
+		if (!(dest_str = zend_flf_parse_arg_str_slow(arg ## arg_num, arg_num))) { \
 			zend_wrong_parameter_type_error(arg_num, Z_EXPECTED_ARRAY_OR_STRING, arg ## arg_num); \
 			goto flf_clean; \
 		} \
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -8843,7 +8843,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMP|CV, ANY)
 				}
 
 				ZVAL_COPY(&tmp, value);
-				if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
+				if ((str = zend_parse_arg_str_weak(&tmp, 1)) != NULL) {
 					ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
 					zval_ptr_dtor(&tmp);
 					break;
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h

Original file line number	Diff line number	Diff line change
`@@ -509,35 +509,33 @@ static ZEND_COLD bool zend_null_arg_deprecated(const char *fallback_type, uint32`
`509`	`509`	`return !EG(exception);`
`510`	`510`	`}`
`511`	`511`
`512`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_weak(const zval arg, bool dest, uint32_t arg_num) /* {{{ */`
	`512`	`+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_weak(const zval arg, uint32_t arg_num) / {{{ */`
`513`	`513`	`{`
`514`	`514`	`if (EXPECTED(Z_TYPE_P(arg) <= IS_STRING)) {`
`515`	`515`	`if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("bool", arg_num)) {`
`516`		`- return 0;`
	`516`	`+ return ZPP_PARSE_BOOL_STATUS_ERROR;`
`517`	`517`	`}`
`518`		`- *dest = zend_is_true(arg);`
`519`		`- } else {`
`520`		`- return 0;`
	`518`	`+ return zend_is_true(arg);`
`521`	`519`	`}`
`522`		`- return 1;`
	`520`	`+ return ZPP_PARSE_BOOL_STATUS_ERROR;`
`523`	`521`	`}`
`524`	`522`	`/* }}} */`
`525`	`523`
`526`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_bool_slow(const zval arg, bool dest, uint32_t arg_num) /* {{{ */`
	`524`	`+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_parse_arg_bool_slow(const zval arg, uint32_t arg_num) / {{{ */`
`527`	`525`	`{`
`528`	`526`	`if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {`
`529`		`- return 0;`
	`527`	`+ return ZPP_PARSE_BOOL_STATUS_ERROR;`
`530`	`528`	`}`
`531`		`- return zend_parse_arg_bool_weak(arg, dest, arg_num);`
	`529`	`+ return zend_parse_arg_bool_weak(arg, arg_num);`
`532`	`530`	`}`
`533`	`531`	`/* }}} */`
`534`	`532`
`535`		`-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval arg, bool dest, uint32_t arg_num)`
	`533`	`+ZEND_API zpp_parse_bool_status ZEND_FASTCALL zend_flf_parse_arg_bool_slow(const zval *arg, uint32_t arg_num)`
`536`	`534`	`{`
`537`	`535`	`if (UNEXPECTED(ZEND_FLF_ARG_USES_STRICT_TYPES())) {`
`538`		`- return 0;`
	`536`	`+ return ZPP_PARSE_BOOL_STATUS_ERROR;`
`539`	`537`	`}`
`540`		`- return zend_parse_arg_bool_weak(arg, dest, arg_num);`
	`538`	`+ return zend_parse_arg_bool_weak(arg, arg_num);`
`541`	`539`	`}`
`542`	`540`
`543`	`541`	`ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_weak(const zval arg, zend_long dest, uint32_t arg_num) /* {{{ */`
`@@ -624,44 +622,46 @@ ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_long_slow(const zval *arg, zend_l`
`624`	`622`	`return zend_parse_arg_long_weak(arg, dest, arg_num);`
`625`	`623`	`}`
`626`	`624`
`627`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_weak(const zval arg, double dest, uint32_t arg_num) /* {{{ */`
	`625`	`+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_weak(const zval arg, uint32_t arg_num) / {{{ */`
`628`	`626`	`{`
`629`	`627`	`if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {`
`630`		`- *dest = (double)Z_LVAL_P(arg);`
	`628`	`+ return (double)Z_LVAL_P(arg);`
`631`	`629`	`} else if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {`
`632`	`630`	`zend_long l;`
	`631`	`+ double dval;`
`633`	`632`	`uint8_t type;`
`634`	`633`
`635`		`- if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, dest)) != IS_DOUBLE)) {`
	`634`	`+ if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, &dval)) != IS_DOUBLE)) {`
`636`	`635`	`if (EXPECTED(type != 0)) {`
`637`		`- *dest = (double)(l);`
	`636`	`+ return (double)(l);`
`638`	`637`	`} else {`
`639`		`- return 0;`
	`638`	`+ return NAN;`
`640`	`639`	`}`
	`640`	`+ } else {`
	`641`	`+ return dval;`
`641`	`642`	`}`
`642`	`643`	`} else if (EXPECTED(Z_TYPE_P(arg) < IS_TRUE)) {`
`643`	`644`	`if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("float", arg_num)) {`
`644`		`- return 0;`
	`645`	`+ return NAN;`
`645`	`646`	`}`
`646`		`- *dest = 0.0;`
	`647`	`+ return 0.0;`
`647`	`648`	`} else if (EXPECTED(Z_TYPE_P(arg) == IS_TRUE)) {`
`648`		`- *dest = 1.0;`
	`649`	`+ return 1.0;`
`649`	`650`	`} else {`
`650`		`- return 0;`
	`651`	`+ return NAN;`
`651`	`652`	`}`
`652`		`- return 1;`
`653`	`653`	`}`
`654`	`654`	`/* }}} */`
`655`	`655`
`656`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_double_slow(const zval arg, double dest, uint32_t arg_num) /* {{{ */`
	`656`	`+ZEND_API double ZEND_FASTCALL zend_parse_arg_double_slow(const zval arg, uint32_t arg_num) / {{{ */`
`657`	`657`	`{`
`658`	`658`	`if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {`
`659`	`659`	`/* SSTH Exception: IS_LONG may be accepted instead as IS_DOUBLE */`
`660`		`- *dest = (double)Z_LVAL_P(arg);`
	`660`	`+ return (double)Z_LVAL_P(arg);`
`661`	`661`	`} else if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {`
`662`		`- return 0;`
	`662`	`+ return NAN;`
`663`	`663`	`}`
`664`		`- return zend_parse_arg_double_weak(arg, dest, arg_num);`
	`664`	`+ return zend_parse_arg_double_weak(arg, arg_num);`
`665`	`665`	`}`
`666`	`666`	`/* }}} */`
`667`	`667`
`@@ -728,58 +728,58 @@ ZEND_API bool ZEND_FASTCALL zend_parse_arg_number_or_str_slow(zval arg, zval *`
`728`	`728`	`return true;`
`729`	`729`	`}`
`730`	`730`
`731`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_weak(zval arg, zend_string dest, uint32_t arg_num) / {{{ */`
	`731`	`+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_weak(zval arg, uint32_t arg_num) / {{{ */`
`732`	`732`	`{`
`733`	`733`	`if (EXPECTED(Z_TYPE_P(arg) < IS_STRING)) {`
`734`	`734`	`if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) && !zend_null_arg_deprecated("string", arg_num)) {`
`735`		`- return 0;`
	`735`	`+ return NULL;`
`736`	`736`	`}`
`737`	`737`	`convert_to_string(arg);`
`738`		`- *dest = Z_STR_P(arg);`
	`738`	`+ return Z_STR_P(arg);`
`739`	`739`	`} else if (UNEXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {`
`740`	`740`	`zend_object *zobj = Z_OBJ_P(arg);`
`741`	`741`	`zval obj;`
`742`	`742`	`if (zobj->handlers->cast_object(zobj, &obj, IS_STRING) == SUCCESS) {`
`743`	`743`	`OBJ_RELEASE(zobj);`
`744`	`744`	`ZVAL_COPY_VALUE(arg, &obj);`
`745`		`- *dest = Z_STR_P(arg);`
`746`		`- return 1;`
	`745`	`+ return Z_STR_P(arg);`
`747`	`746`	`}`
`748`		`- return 0;`
	`747`	`+ return NULL;`
`749`	`748`	`} else {`
`750`		`- return 0;`
	`749`	`+ return NULL;`
`751`	`750`	`}`
`752`		`- return 1;`
`753`	`751`	`}`
`754`	`752`	`/* }}} */`
`755`	`753`
`756`		`-ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_slow(zval arg, zend_string dest, uint32_t arg_num) / {{{ */`
	`754`	`+ZEND_API zend_string* ZEND_FASTCALL zend_parse_arg_str_slow(zval arg, uint32_t arg_num) / {{{ */`
`757`	`755`	`{`
`758`	`756`	`if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {`
`759`		`- return 0;`
	`757`	`+ return NULL;`
`760`	`758`	`}`
`761`		`- return zend_parse_arg_str_weak(arg, dest, arg_num);`
	`759`	`+ return zend_parse_arg_str_weak(arg, arg_num);`
`762`	`760`	`}`
`763`	`761`	`/* }}} */`
`764`	`762`
`765`		`-ZEND_API bool ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval arg, zend_string *dest, uint32_t arg_num)`
	`763`	`+ZEND_API zend_string* ZEND_FASTCALL zend_flf_parse_arg_str_slow(zval *arg, uint32_t arg_num)`
`766`	`764`	`{`
`767`	`765`	`if (UNEXPECTED(ZEND_FLF_ARG_USES_STRICT_TYPES())) {`
`768`		`- return 0;`
	`766`	`+ return NULL;`
`769`	`767`	`}`
`770`		`- return zend_parse_arg_str_weak(arg, dest, arg_num);`
	`768`	`+ return zend_parse_arg_str_weak(arg, arg_num);`
`771`	`769`	`}`
`772`	`770`
`773`	`771`	`ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_or_long_slow(zval arg, zend_string dest_str, zend_long dest_long, uint32_t arg_num) /* {{{ */`
`774`	`772`	`{`
	`773`	`+ zend_string *str;`
`775`	`774`	`if (UNEXPECTED(ZEND_ARG_USES_STRICT_TYPES())) {`
`776`	`775`	`return 0;`
`777`	`776`	`}`
`778`	`777`	`if (zend_parse_arg_long_weak(arg, dest_long, arg_num)) {`
`779`	`778`	`*dest_str = NULL;`
`780`	`779`	`return 1;`
`781`		`- } else if (zend_parse_arg_str_weak(arg, dest_str, arg_num)) {`
	`780`	`+ } else if ((str = zend_parse_arg_str_weak(arg, arg_num)) != NULL) {`
`782`	`781`	`*dest_long = 0;`
	`782`	`+ *dest_str = str;`
`783`	`783`	`return 1;`
`784`	`784`	`} else {`
`785`	`785`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -8843,7 +8843,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST\|TMP\|CV, ANY)`
`8843`	`8843`	`}`
`8844`	`8844`
`8845`	`8845`	`ZVAL_COPY(&tmp, value);`
`8846`		`- if (zend_parse_arg_str_weak(&tmp, &str, 1)) {`
	`8846`	`+ if ((str = zend_parse_arg_str_weak(&tmp, 1)) != NULL) {`
`8847`	`8847`	`ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));`
`8848`	`8848`	`zval_ptr_dtor(&tmp);`
`8849`	`8849`	`break;`