PHP 8.4 support (#148)

Co-authored-by: Akmal Fairuz <[email protected]>

Author: dktapps

.github/workflows/main.yml

@@ -15,6 +15,7 @@ jobs:
           - 8.1.33
           - 8.2.29
           - 8.3.25
+          - 8.4.12
 
     uses: ./.github/workflows/main-php-matrix.yml
     with:
@@ -33,6 +34,8 @@ jobs:
             vs-crt: vs16
           - php: 8.3.25
             vs-crt: vs16
+          - php: 8.4.12
+            vs-crt: vs17
 
     uses: ./.github/workflows/main-php-matrix-windows.yml
     with:

src/copy.c

@@ -351,7 +351,13 @@ static zval* pmmpthread_copy_literals(const pmmpthread_ident_t* owner, zval *old
 
 	memcpy(memory, old, sizeof(zval) * last);
 	while (literal < end) {
-		if (pmmpthread_copy_zval(owner, literal, old_literal) == FAILURE) {
+		if (Z_TYPE_P(old_literal) == IS_UNDEF) {
+			/*
+			 * Literals may have unused holes in 8.4 due to compiler optimizations
+			 * See https://github.com/php/php-src/commit/1e7aac315ef1 (zend_compile_rope_finalize)
+			 */
+			ZVAL_UNDEF(literal);
+		} else if (pmmpthread_copy_zval(owner, literal, old_literal) == FAILURE) {
 			zend_error_at_noreturn(
 				E_CORE_ERROR,
 				filename,
@@ -437,6 +443,9 @@ static zend_op* pmmpthread_copy_opcodes(zend_op_array *op_array, zval *literals,
 				case ZEND_JMP_NULL:
 #if PHP_VERSION_ID >= 80300
 				case ZEND_BIND_INIT_STATIC_OR_JMP:
+#endif
+#if PHP_VERSION_ID >= 80400
+				case ZEND_JMP_FRAMELESS:
 #endif
 					opline->op2.jmp_addr = &copy[opline->op2.jmp_addr - op_array->opcodes];
 					break;

src/handlers.c

@@ -48,7 +48,11 @@ HashTable* pmmpthread_read_debug(PMMPTHREAD_READ_DEBUG_PASSTHRU_D) {
 HashTable* pmmpthread_read_properties(PMMPTHREAD_READ_PROPERTIES_PASSTHRU_D) {
 	pmmpthread_zend_object_t* threaded = PMMPTHREAD_FETCH_FROM(object);
 
+#if PHP_VERSION_ID >= 80400
+	zend_std_get_properties_ex(&threaded->std);
+#else
 	rebuild_object_properties(&threaded->std);
+#endif
 
 	pmmpthread_store_tohash(
 		&threaded->std, threaded->std.properties);
@@ -75,6 +79,81 @@ zval* pmmpthread_read_dimension(PMMPTHREAD_READ_DIMENSION_PASSTHRU_D) {
 	return rv;
 }
 
+#if PHP_VERSION_ID >= 80400
+/* {{{
+* Copy pasta from zend_object_handlers.c because the equivalent over there had to be static...
+*/
+static bool zend_is_in_hook(const zend_property_info *prop_info)
+{
+	zend_execute_data *execute_data = EG(current_execute_data);
+	if (!execute_data || !EX(func) || !EX(func)->common.prop_info) {
+		return false;
+	}
+
+	const zend_property_info *parent_info = EX(func)->common.prop_info;
+	ZEND_ASSERT(prop_info->prototype && parent_info->prototype);
+	return prop_info->prototype == parent_info->prototype;
+} /* }}} */
+
+/* {{{
+* Copy pasta from zend_object_handlers.c because the equivalent over there had to be static...
+*/
+static bool zend_should_call_hook(const zend_property_info *prop_info, const zend_object *obj)
+{
+	if (!zend_is_in_hook(prop_info)) {
+		return true;
+	}
+
+	/* execute_data and This are guaranteed to be set if zend_is_in_hook() returns true. */
+	zend_object *parent_obj = Z_OBJ(EG(current_execute_data)->This);
+	if (parent_obj == obj) {
+		return false;
+	}
+
+	/* pmmpthread objects can't be lazy */
+	/*
+	if (zend_object_is_lazy_proxy(parent_obj)
+		&& zend_lazy_object_initialized(parent_obj)
+		&& zend_lazy_object_get_instance(parent_obj) == obj) {
+		return false;
+	}
+	*/
+
+	return true;
+} /* }}} */
+
+/* {{{
+* Copy pasta from zend_object_handlers.c because the equivalent over there had to be static...
+*/
+static void zend_throw_no_prop_backing_value_access(zend_string *class_name, zend_string *prop_name, bool is_read)
+{
+	zend_throw_error(NULL, "Must not %s virtual property %s::$%s",
+		is_read ? "read from" : "write to",
+		ZSTR_VAL(class_name), ZSTR_VAL(prop_name));
+} /* }}} */
+
+/* {{{
+* Copy pasta from zend_object_handlers.c because the equivalent over there had to be static...
+*/
+static bool zend_call_get_hook(
+	const zend_property_info *prop_info, zend_string *prop_name,
+	zend_function *get, zend_object *zobj, zval *rv)
+{
+	if (!zend_should_call_hook(prop_info, zobj)) {
+		if (UNEXPECTED(prop_info->flags & ZEND_ACC_VIRTUAL)) {
+			zend_throw_no_prop_backing_value_access(zobj->ce->name, prop_name, /* is_read */ true);
+		}
+		return false;
+	}
+
+	GC_ADDREF(zobj);
+	zend_call_known_instance_method_with_0_params(get, zobj, rv);
+	OBJ_RELEASE(zobj);
+
+	return true;
+}
+#endif //PHP_VERSION_ID >= 80400
+
 zval* pmmpthread_read_property(PMMPTHREAD_READ_PROPERTY_PASSTHRU_D) {
 	zval zmember;
 	zend_guard* guard;
@@ -87,9 +166,40 @@ zval* pmmpthread_read_property(PMMPTHREAD_READ_PROPERTY_PASSTHRU_D) {
 		(*guard) &= ~IN_GET;
 	} else {
 		zend_property_info* info = zend_get_property_info(object->ce, member, 0);
+
 		if (info == ZEND_WRONG_PROPERTY_INFO) {
-			rv = &EG(uninitialized_zval);
-		} else if (info == NULL || (info->flags & ZEND_ACC_STATIC) != 0) { //dynamic property
+			return &EG(uninitialized_zval);
+		}
+
+		if (info != NULL) {
+			if (info->flags & ZEND_ACC_STATIC) {
+				info = NULL;
+#if PHP_VERSION_ID >= 80400
+			} else if (info->hooks != NULL) {
+				zend_function* get = info->hooks[ZEND_PROPERTY_HOOK_GET];
+				if (!get) {
+					if (info->flags & ZEND_ACC_VIRTUAL) {
+						zend_throw_error(NULL, "Property %s::$%s is write-only",
+							ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
+						return &EG(uninitialized_zval);
+					}
+					//php-src has some checks for indirection here - we don't need these
+					//since we don't allow indirect modification on ThreadSafe objects anyway
+
+					//fallthru to pmmpthread_store_read() below
+				} else {
+					if (zend_call_get_hook(info, member, get, object, rv)) {
+						return rv;
+					}
+					if (EG(exception)) {
+						return &EG(uninitialized_zval);
+					}
+				}
+#endif
+			}
+		}
+
+		if (info == NULL) { //dynamic property
 			if (pmmpthread_store_read(object, &zmember, type, rv) == FAILURE) {
 				if (type != BP_VAR_IS) {
 					zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
@@ -137,11 +247,11 @@ void pmmpthread_write_dimension(PMMPTHREAD_WRITE_DIMENSION_PASSTHRU_D) {
 
 zval* pmmpthread_write_property(PMMPTHREAD_WRITE_PROPERTY_PASSTHRU_D) {
 	zval zmember;
-	zval tmp;
+	zval coerced_value;
 	zend_guard* guard;
 
 	ZVAL_STR(&zmember, member);
-	ZVAL_UNDEF(&tmp);
+	ZVAL_UNDEF(&coerced_value);
 
 	if (object->ce->__set && (guard = zend_get_property_guard(object, member)) && !((*guard) & IN_SET)) {
 		zval rv;
@@ -154,42 +264,83 @@ zval* pmmpthread_write_property(PMMPTHREAD_WRITE_PROPERTY_PASSTHRU_D) {
 		if (Z_TYPE(rv) != IS_UNDEF)
 			zval_dtor(&rv);
 	} else {
-		bool ok = true;
+		bool write_store = true;
 		zend_property_info* info = zend_get_property_info(object->ce, member, 0);
-		if (info != ZEND_WRONG_PROPERTY_INFO) {
-			if (info != NULL && (info->flags & ZEND_ACC_STATIC) == 0) {
-				ZVAL_STR(&zmember, info->name); //use mangled name to avoid private member shadowing issues
+		if (info == ZEND_WRONG_PROPERTY_INFO) {
+			return &EG(error_zval);
+		}
 
+		//zend_verify_property_type() might modify the value
+		//value is not copied before we receive it, so it might be
+		//from opcache protected memory which we can't modify
+		ZVAL_COPY(&coerced_value, value);
+
+		if (info != NULL && (info->flags & ZEND_ACC_STATIC) == 0) {
+			ZVAL_STR(&zmember, info->name); //use mangled name to avoid private member shadowing issues
+
+#if PHP_VERSION_ID >= 80400
+			if (info->hooks != NULL) {
+				zend_function* set = info->hooks[ZEND_PROPERTY_HOOK_SET];
+
+				if (!set) {
+					if (info->flags & ZEND_ACC_VIRTUAL) {
+						zend_throw_error(NULL, "Property %s::$%s is read-only", ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
+						value = &EG(error_zval);
+						write_store = false;
+					}
+					//fallthru to normal write
+				} else if (!zend_should_call_hook(info, object)) {
+					if (info->flags & ZEND_ACC_VIRTUAL) {
+						zend_throw_no_prop_backing_value_access(object->ce->name, member, /* is_read */ false);
+						value = &EG(error_zval);
+						write_store = false;
+					}
+					//fallthru to normal write
+				} else {
+					//call hook or die trying
+					write_store = false;
+					if (UNEXPECTED(info->flags & ZEND_ACC_PPP_SET_MASK
+						&& !zend_asymmetric_property_has_set_access(info))) {
+						zend_asymmetric_visibility_property_modification_error(info, "modify");
+						value = &EG(error_zval);
+					} else {
+						GC_ADDREF(object);
+						zend_call_known_instance_method_with_1_params(set, object, NULL, value);
+						OBJ_RELEASE(object);
+					}
+				}
+			}
+#endif
+			if (write_store) { //if hooked, the setter will do the type verification, so we can skip this
 				zend_execute_data* execute_data = EG(current_execute_data);
 				bool strict = execute_data
 					&& execute_data->func
 					&& ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data));
 
-				//zend_verify_property_type() might modify the value
-				//value is not copied before we receive it, so it might be
-				//from opcache protected memory which we can't modify
-				ZVAL_COPY(&tmp, value);
-				value = &tmp;
-
-				if (ZEND_TYPE_IS_SET(info->type) && !zend_verify_property_type(info, value, strict)) {
-					ok = false;
+				if (ZEND_TYPE_IS_SET(info->type) && !zend_verify_property_type(info, &coerced_value, strict)) {
+					write_store = false;
 				}
 			}
+		}
 
-			if (ok && pmmpthread_store_write(object, &zmember, value, PMMPTHREAD_STORE_NO_COERCE_ARRAY) == FAILURE && !EG(exception)) {
-				zend_throw_error(
-					pmmpthread_ce_nts_value_error,
-					"Cannot assign non-thread-safe value of type %s to thread-safe class property %s::$%s",
-					zend_zval_type_name(value),
-					ZSTR_VAL(object->ce->name),
-					ZSTR_VAL(member)
-				);
-			}
+		if (write_store && pmmpthread_store_write(object, &zmember, &coerced_value, PMMPTHREAD_STORE_NO_COERCE_ARRAY) == FAILURE && !EG(exception)) {
+			zend_throw_error(
+				pmmpthread_ce_nts_value_error,
+				"Cannot assign non-thread-safe value of type %s to thread-safe class property %s::$%s",
+				zend_zval_type_name(value),
+				ZSTR_VAL(object->ce->name),
+				ZSTR_VAL(member)
+			);
 		}
 	}
 
-	zval_ptr_dtor(&tmp);
+	zval_ptr_dtor(&coerced_value);
 
+	//technically, this should return the coercedValue, but PHP doesn't give us a way to do that
+	//and we can't return a ptr to a stack variable
+	//so instead this will mirror the behaviour of a hooked property and return the original, non-coerced value
+	//this is an unfortunate deviation from the standard behaviour, but since we should only see coercion in
+	//weak mode anyway, it shouldn't cause anyone any serious headaches.
 	return EG(exception) ? &EG(error_zval) : value;
 }
 /* }}} */
@@ -222,16 +373,55 @@ int pmmpthread_has_property(PMMPTHREAD_HAS_PROPERTY_PASSTHRU_D) {
 		(*guard) &= ~IN_ISSET;
 
 		if (Z_TYPE(rv) != IS_UNDEF) {
+			//TODO: this doesn't account for ZEND_PROPERTY_NOT_EMPTY
 			isset = zend_is_true(&rv);
 			zval_dtor(&rv);
 		}
 	} else {
 		zend_property_info* info = zend_get_property_info(object->ce, member, 1);
+		bool read_store = true;
 		if (info != ZEND_WRONG_PROPERTY_INFO) {
 			if (info != NULL && (info->flags & ZEND_ACC_STATIC) == 0) {
-				ZVAL_STR(&zmember, info->name); //defined property, use mangled name
+				ZVAL_STR(&zmember, info->name);
+#if PHP_VERSION_ID >= 80400
+				if (info->hooks != NULL) {
+					zend_function* get = info->hooks[ZEND_PROPERTY_HOOK_GET];
+
+					if (has_set_exists == ZEND_PROPERTY_EXISTS) {
+						isset = 1;
+						read_store = false;
+					} else if (get == NULL) {
+						if (info->flags & ZEND_ACC_VIRTUAL) {
+							zend_throw_error(NULL, "Property %s::$%s is write-only",
+								ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
+							isset = 0;
+							read_store = false;
+						}
+
+						//fallthru to store read
+					} else {
+						zval rv;
+						if (zend_call_get_hook(info, member, get, object, &rv)) {
+							read_store = false;
+							if (has_set_exists == ZEND_PROPERTY_NOT_EMPTY) {
+								isset = zend_is_true(&rv);
+							} else {
+								ZEND_ASSERT(has_set_exists == ZEND_PROPERTY_ISSET);
+								isset = Z_TYPE(rv) != IS_NULL
+									&& (Z_TYPE(rv) != IS_REFERENCE || Z_TYPE_P(Z_REFVAL(rv)) != IS_NULL);
+							}
+							zval_ptr_dtor(&rv);
+						} else if (EG(exception)) {
+							read_store = false;
+						}
+					}
+				}
+#endif
+			}
+
+			if (read_store) {
+				isset = pmmpthread_store_isset(object, &zmember, has_set_exists);
 			}
-			isset = pmmpthread_store_isset(object, &zmember, has_set_exists);
 		} else isset = 0;
 	}
 	return isset;
@@ -270,6 +460,13 @@ void pmmpthread_unset_property(PMMPTHREAD_UNSET_PROPERTY_PASSTHRU_D) {
 		if (info != ZEND_WRONG_PROPERTY_INFO) {
 			if (info != NULL && (info->flags & ZEND_ACC_STATIC) == 0) {
 				ZVAL_STR(&zmember, info->name); //defined property, use mangled name
+#if PHP_VERSION_ID >= 80400
+				if (info->hooks != NULL) {
+					zend_throw_error(NULL, "Cannot unset hooked property %s::$%s",
+						ZSTR_VAL(object->ce->name), ZSTR_VAL(member));
+					return;
+				}
+#endif
 			}
 			pmmpthread_store_delete(object, &zmember);
 		}

src/object.c

@@ -248,7 +248,7 @@ static inline void pmmpthread_base_write_property_defaults(pmmpthread_zend_objec
 			zval* value;
 			int result;
 
-			if (info->flags & ZEND_ACC_STATIC) {
+			if (!PMMPTHREAD_OBJECT_PROPERTY(info)) {
 				continue;
 			}
 

src/pmmpthread.h

@@ -163,6 +163,12 @@ typedef struct _pmmpthread_call_t {
 
 #define PMMPTHREAD_CALL_EMPTY {empty_fcall_info, empty_fcall_info_cache}
 
+#if PHP_VERSION_ID >= 80400
+#define PMMPTHREAD_OBJECT_PROPERTY(prop_info) ((prop_info->flags & (ZEND_ACC_STATIC | ZEND_ACC_VIRTUAL)) == 0)
+#else
+#define PMMPTHREAD_OBJECT_PROPERTY(prop_info) ((prop_info->flags & ZEND_ACC_STATIC) == 0)
+#endif
+
 /* this is a copy of the same struct in zend_closures.c, which unfortunately isn't exported */
 typedef struct _zend_closure {
 	zend_object       std;