bless zend_partial with zend_closure debug info

krakjoe · krakjoe · commit b131bfead700 · 2021-05-13T11:25:06.000+02:00
diff --git a/Zend/tests/partial_function/object-constructor.phpt b/Zend/tests/partial_function/object-constructor.phpt
@@ -47,7 +47,17 @@ catch (RuntimeException $e) {
 
 ?>
 --EXPECTF--
-object(Closure)#%d (1) {
+object(Closure)#%d (3) {
+  ["this"]=>
+  object(Foo)#%d (0) {
+  }
+  ["parameter"]=>
+  array(2) {
+    ["$one"]=>
+    string(10) "<required>"
+    ["$two"]=>
+    string(10) "<required>"
+  }
   ["args"]=>
   array(2) {
     ["one"]=>
@@ -59,7 +69,10 @@ object(Closure)#%d (1) {
 Rocking Foo::__construct [1, 2]
 object(Foo)#%d (0) {
 }
-object(Closure)#%d (1) {
+object(Closure)#%d (2) {
+  ["this"]=>
+  object(Bar)#%d (0) {
+  }
   ["args"]=>
   array(0) {
   }
diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
@@ -553,7 +553,7 @@ int zend_closure_get_closure(zend_object *obj, zend_class_entry **ce_ptr, zend_f
 /* }}} */
 
 /* *is_temp is int due to Object Handler API */
-static HashTable *zend_closure_get_debug_info(zend_object *object, int *is_temp) /* {{{ */
+HashTable *zend_closure_get_debug_info(zend_object *object, int *is_temp) /* {{{ */
 {
 	zend_closure *closure = (zend_closure *)object;
 	zval val;
diff --git a/Zend/zend_closures.h b/Zend/zend_closures.h
@@ -29,6 +29,7 @@ BEGIN_EXTERN_C()
 void zend_register_closure_ce(void);
 void zend_closure_bind_var(zval *closure_zv, zend_string *var_name, zval *var);
 void zend_closure_bind_var_ex(zval *closure_zv, uint32_t offset, zval *val);
+HashTable *zend_closure_get_debug_info(zend_object *object, int *is_temp);
 
 extern ZEND_API zend_class_entry *zend_ce_closure;
 
diff --git a/Zend/zend_partial.c b/Zend/zend_partial.c
@@ -21,26 +21,22 @@
 #include "zend_closures.h"
 #include "zend_partial.h"
 
-zend_object_handlers zend_partial_handlers;
+typedef struct _zend_partial {
+    zend_object     std;
+    zend_function   prototype;
+    zval            This;
+    zend_function   func;
+    zend_function   trampoline;
+    uint32_t        argc;
+    zval           *argv;
+    zend_array     *named;
+} zend_partial;
+
+static zend_object_handlers zend_partial_handlers;
 
 #define ZEND_PARTIAL_PROPERTY_ERROR() \
 	zend_throw_error(NULL, "Partial closures cannot have properties")
 
-typedef struct _zend_partial_applied {
-    zval           This;
-    uint32_t       argc;
-    zval          *argv;
-    zend_array    *named;
-} zend_partial_applied;
-
-typedef struct _zend_partial {
-    zend_object            std;
-    zend_function          prototype;
-    zend_function          func;
-    zend_function          trampoline;
-    zend_partial_applied   frame;
-} zend_partial;
-
 static zend_always_inline zend_object* zend_partial_this(zend_object *object) {
     while (object && instanceof_function(object->ce, zend_ce_closure)) {
         zend_partial *ptr = (zend_partial*) object;
@@ -49,8 +45,8 @@ static zend_always_inline zend_object* zend_partial_this(zend_object *object) {
             break;
         }
         
-        if (Z_TYPE(ptr->frame.This) == IS_OBJECT) {
-            object = Z_OBJ(ptr->frame.This);
+        if (Z_TYPE(ptr->This) == IS_OBJECT) {
+            object = Z_OBJ(ptr->This);
         } else {
             object = NULL;
         }
@@ -107,8 +103,8 @@ static zend_always_inline void zend_partial_prototype_u(zend_partial *partial, z
         partial->prototype.op_array.arg_info++;
     }
 
-    zval *arg = partial->frame.argv,
-         *aend = arg + partial->frame.argc;
+    zval *arg = partial->argv,
+         *aend = arg + partial->argc;
 
     partial->prototype.common.num_args = 0;
 
@@ -160,8 +156,8 @@ static zend_always_inline void zend_partial_prototype_i(zend_partial *partial, z
         partial->prototype.internal_function.arg_info++;
     }
 
-    zval *arg = partial->frame.argv,
-         *aend = arg + partial->frame.argc;
+    zval *arg = partial->argv,
+         *aend = arg + partial->argc;
 
     partial->prototype.common.num_args = 0;
 
@@ -222,8 +218,8 @@ static zend_always_inline zend_object* zend_partial_new(zend_class_entry *type)
 }
 
 static zend_always_inline void zend_partial_debug_i(zend_partial *partial, HashTable *ht) {
-    zval *arg = partial->frame.argv,
-         *aend = arg + partial->frame.argc;
+    zval *arg = partial->argv,
+         *aend = arg + partial->argc;
     zend_internal_arg_info *info = partial->func.internal_function.arg_info,
                            *iend = info + partial->func.internal_function.num_args;
 
@@ -254,8 +250,8 @@ static zend_always_inline void zend_partial_debug_i(zend_partial *partial, HashT
 }
 
 static zend_always_inline void zend_partial_debug_u(zend_partial *partial, HashTable *ht) {
-    zval *arg = partial->frame.argv,
-         *aend = arg + partial->frame.argc;
+    zval *arg = partial->argv,
+         *aend = arg + partial->argc;
     zend_arg_info *info = partial->func.op_array.arg_info,
                   *iend = info + partial->func.op_array.num_args;
 
@@ -290,9 +286,7 @@ static HashTable *zend_partial_debug(zend_object *object, int *is_temp) {
     zval args;
     HashTable *ht;
 
-    *is_temp = 1;
-
-    ht = zend_new_array(1);
+    ht = zend_closure_get_debug_info(object, is_temp);
 
     array_init(&args);
     zend_hash_update(ht, ZSTR_KNOWN(ZEND_STR_ARGS), &args);
@@ -341,8 +335,8 @@ static HashTable *zend_partial_get_gc(zend_object *obj, zval **table, int *n)
 {
 	zend_partial *partial = (zend_partial *)obj;
 
-	*table = Z_TYPE(partial->frame.This) != IS_NULL ? &partial->frame.This : NULL;
-	*n = Z_TYPE(partial->frame.This) != IS_NULL ? 1 : 0;
+	*table = Z_TYPE(partial->This) != IS_NULL ? &partial->This : NULL;
+	*n = Z_TYPE(partial->This) != IS_NULL ? 1 : 0;
 
 	return (partial->func.type == ZEND_USER_FUNCTION) ?
 		ZEND_MAP_PTR_GET(partial->func.op_array.static_variables_ptr) : NULL;
@@ -378,8 +372,8 @@ static int zend_partial_get_trampoline(zend_object *obj, zend_class_entry **ce_p
 static void zend_partial_free(zend_object *object) {
     zend_partial *partial = (zend_partial*) object;
 
-    zval *arg = partial->frame.argv,
-         *end = arg + partial->frame.argc;
+    zval *arg = partial->argv,
+         *end = arg + partial->argc;
 
     while (arg < end) {
         if (Z_OPT_REFCOUNTED_P(arg)) {
@@ -388,10 +382,10 @@ static void zend_partial_free(zend_object *object) {
         arg++;
     }
 
-    efree_size(partial->frame.argv, sizeof(zval) * partial->frame.argc);
+    efree_size(partial->argv, sizeof(zval) * partial->argc);
 
-    if (partial->frame.named) {
-        zend_array_release(partial->frame.named);
+    if (partial->named) {
+        zend_array_release(partial->named);
     }
 
     zend_arg_info *info = partial->prototype.common.arg_info;
@@ -406,7 +400,7 @@ static void zend_partial_free(zend_object *object) {
         destroy_zend_function(&partial->func);
     }
 
-    zval_ptr_dtor(&partial->frame.This);
+    zval_ptr_dtor(&partial->This);
 
     zend_object_std_dtor(object);
 }
@@ -442,17 +436,17 @@ ZEND_NAMED_FUNCTION(zend_partial_call_magic)
 
 	fci.size = sizeof(zend_fcall_info);
 	fci.retval = return_value;
-	fci.param_count = MAX(partial->func.common.num_args, partial->frame.argc + num_params);
+	fci.param_count = MAX(partial->func.common.num_args, partial->argc + num_params);
 	fci.params = ecalloc(sizeof(zval), fci.param_count);
 	fcc.function_handler = &partial->func;
 
-	if (!Z_ISUNDEF(partial->frame.This)) {
+	if (!Z_ISUNDEF(partial->This)) {
 	    fci.object =
 	        fcc.object =
-	            zend_partial_this(Z_OBJ(partial->frame.This));
+	            zend_partial_this(Z_OBJ(partial->This));
 	}
 
-	memcpy(fci.params, partial->frame.argv, partial->frame.argc * sizeof(zval));
+	memcpy(fci.params, partial->argv, partial->argc * sizeof(zval));
 
     zval *arg = fci.params,
          *aend = arg + fci.param_count,
@@ -471,14 +465,14 @@ ZEND_NAMED_FUNCTION(zend_partial_call_magic)
         arg++;
     }
 
-    if (partial->frame.named) {
+    if (partial->named) {
         if (!named_args) {
             named_args = 
-                partial->frame.named;
+                partial->named;
             GC_ADDREF(named_args);
         } else {
             HashTable *nested = 
-                zend_array_dup(partial->frame.named);
+                zend_array_dup(partial->named);
             
             zend_hash_merge(
                 nested,
@@ -500,7 +494,7 @@ ZEND_NAMED_FUNCTION(zend_partial_call_magic)
         }
     }
 
-    if (partial->frame.named) {
+    if (partial->named) {
         zend_array_release(named_args);
     }
     
@@ -510,7 +504,7 @@ ZEND_NAMED_FUNCTION(zend_partial_call_magic)
         zval_ptr_dtor(return_value);
         
         RETVAL_OBJ(
-            Z_OBJ(partial->frame.This));
+            Z_OBJ(partial->This));
     }
     
     if (!fcc.function_handler) {
@@ -531,61 +525,59 @@ void zend_partial_apply(zval *result, zend_execute_data *call) {
     if ((parent = zend_partial_parent(&call->This))) {
         function  = &parent->func;
         prototype = &parent->prototype;
-        
-        zend_partial_applied *frame = &parent->frame;
 
-        partial->frame.argc = frame->argc + ZEND_CALL_NUM_ARGS(call);
-        partial->frame.argv = ecalloc(partial->frame.argc, sizeof(zval));
+        partial->argc = parent->argc + ZEND_CALL_NUM_ARGS(call);
+        partial->argv = ecalloc(partial->argc, sizeof(zval));
 
-        memcpy(partial->frame.argv,
-            frame->argv, frame->argc * sizeof(zval));
+        memcpy(partial->argv,
+            parent->argv, parent->argc * sizeof(zval));
 
         uint32_t arg = 0,
-                 aend = frame->argc;
+                 aend = parent->argc;
         zval *param = ZEND_CALL_ARG(call, 1),
              *pend = param + ZEND_CALL_NUM_ARGS(call);
 
         while (arg < aend && param < pend) {
-            if (Z_TYPE(partial->frame.argv[arg]) == IS_UNDEF) {
+            if (Z_TYPE(partial->argv[arg]) == IS_UNDEF) {
                 if (!Z_ISUNDEF_P(param)) {
                     ZVAL_COPY_VALUE(
-                        &partial->frame.argv[arg], param);
+                        &partial->argv[arg], param);
                 }
                 param++;
             }
             arg++;
         }
 
         if ((ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
-            if (frame->named) {
-                partial->frame.named = zend_array_dup(frame->named);
+            if (parent->named) {
+                partial->named = zend_array_dup(parent->named);
 
                 zend_hash_merge(
-                    partial->frame.named,
+                    partial->named,
                     call->extra_named_params, zval_copy_ctor, true);
             } else {
-                partial->frame.named =  
+                partial->named =
                     call->extra_named_params;
                 GC_ADDREF(call->extra_named_params);
             }
         }
     } else {
         function = call->func;
 
-        partial->frame.argc = ZEND_CALL_NUM_ARGS(call);
-        partial->frame.argv = ecalloc(partial->frame.argc, sizeof(zval));
+        partial->argc = ZEND_CALL_NUM_ARGS(call);
+        partial->argv = ecalloc(partial->argc, sizeof(zval));
 
-        memcpy(partial->frame.argv,
-            ZEND_CALL_ARG(call, 1), partial->frame.argc * sizeof(zval));
+        memcpy(partial->argv,
+            ZEND_CALL_ARG(call, 1), partial->argc * sizeof(zval));
         
         if ((ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
-            partial->frame.named = 
+            partial->named =
                 call->extra_named_params;
             GC_ADDREF(call->extra_named_params);
         }
     }
 
-    ZVAL_COPY(&partial->frame.This, &call->This);
+    ZVAL_COPY(&partial->This, &call->This);
 
     memcpy(&partial->func, function,
            function->type == ZEND_INTERNAL_FUNCTION ?
@@ -601,7 +593,7 @@ void zend_partial_apply(zval *result, zend_execute_data *call) {
     
     if (partial->func.common.fn_flags & ZEND_ACC_CTOR) {
         GC_ADD_FLAGS(
-            Z_OBJ(partial->frame.This), IS_OBJ_DESTRUCTOR_CALLED);
+            Z_OBJ(partial->This), IS_OBJ_DESTRUCTOR_CALLED);
     }
 
     if (partial->func.type == ZEND_USER_FUNCTION) {

Original file line number	Diff line number	Diff line change
`@@ -553,7 +553,7 @@ int zend_closure_get_closure(zend_object obj, zend_class_entry *ce_ptr, zend_f`
`553`	`553`	`/* }}} */`
`554`	`554`
`555`	`555`	`/* is_temp is int due to Object Handler API /`
`556`		`-static HashTable zend_closure_get_debug_info(zend_object object, int is_temp) / {{{ */`
	`556`	`+HashTable zend_closure_get_debug_info(zend_object object, int is_temp) / {{{ */`
`557`	`557`	`{`
`558`	`558`	`zend_closure closure = (zend_closure )object;`
`559`	`559`	`zval val;`