ZPP: Return zend_string directly from zend_parse_arg_str_weak()

Girgias · Girgias · commit af69849f66e7 · 2026-04-27T14:53:34.000+01:00
This idea is based on @ndossche previous PR to reduce codebloat: php#18436
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -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
@@ -2178,14 +2178,14 @@ ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_slow(const zval *arg, zend_long
 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 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 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)
@@ -2287,10 +2287,16 @@ static zend_always_inline bool zend_parse_arg_str_ex(zval *arg, zend_string **de
 	} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 		*dest = NULL;
 	} else {
+		zend_string *str;
 		if (frameless) {
-			return zend_flf_parse_arg_str_slow(arg, dest, arg_num);
+			str = zend_flf_parse_arg_str_slow(arg, arg_num);
 		} else {
-			return zend_parse_arg_str_slow(arg, dest, arg_num);
+			str = zend_parse_arg_str_slow(arg, arg_num);
+		}
+		if (str) {
+			*dest = str;
+		} else {
+			return 0;
 		}
 	}
 	return 1;
@@ -2524,7 +2530,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,7 +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 */
@@ -765,7 +764,7 @@ static bool zend_verify_weak_scalar_type_hint(uint32_t type_mask, zval *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;
 	}
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
@@ -8829,8 +8829,8 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMP|CV, ANY)
 		strict = EX_USES_STRICT_TYPES();
 		do {
 			if (EXPECTED(!strict)) {
-				zend_string *str;
 				zval tmp;
+				zend_string *str;
 
 				if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
 					zend_error(E_DEPRECATED,
@@ -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
`@@ -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
`@@ -733,7 +733,6 @@ static bool zend_verify_weak_scalar_type_hint(uint32_t type_mask, zval *arg)`
`733`	`733`	`{`
`734`	`734`	`zend_long lval;`
`735`	`735`	`double dval;`
`736`		`- zend_string *str;`
`737`	`736`	`bool bval;`
`738`	`737`
`739`	`738`	`/* Type preference order: int -> float -> string -> bool */`
`@@ -765,7 +764,7 @@ static bool zend_verify_weak_scalar_type_hint(uint32_t type_mask, zval *arg)`
`765`	`764`	`ZVAL_DOUBLE(arg, dval);`
`766`	`765`	`return true;`
`767`	`766`	`}`
`768`		`- if ((type_mask & MAY_BE_STRING) && zend_parse_arg_str_weak(arg, &str, 0)) {`
	`767`	`+ if ((type_mask & MAY_BE_STRING) && zend_parse_arg_str_weak(arg, 0)) {`
`769`	`768`	`/* on success "arg" is converted to IS_STRING */`
`770`	`769`	`return true;`
`771`	`770`	`}`