Backported call frame initialization improvement

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 523d04e794599b211f9482096f3dd6621ad6ee0a..588022c77005ea63b9d102e2022e2fd385a53dc7 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -482,13 +482,6 @@ union _zend_function {
        zend_internal_function internal_function;
 };
 
-typedef enum _zend_call_kind {
-       ZEND_CALL_NESTED_FUNCTION,      /* stackless VM call to function */
-       ZEND_CALL_NESTED_CODE,          /* stackless VM call to include/require/eval */
-       ZEND_CALL_TOP_FUNCTION,         /* direct VM call to function from external C code */
-       ZEND_CALL_TOP_CODE                      /* direct VM call to "main" code from external C code */
-} zend_call_kind;
-
 struct _zend_execute_data {
        const zend_op       *opline;           /* executed opline                */
        zend_execute_data   *call;             /* current call                   */
@@ -502,24 +495,30 @@ struct _zend_execute_data {
 #endif
 };
 
-#define ZEND_CALL_FUNCTION           (0 << 0)
-#define ZEND_CALL_CODE               (1 << 0)
-#define ZEND_CALL_NESTED             (0 << 1)
-#define ZEND_CALL_TOP                (1 << 1)
-#define ZEND_CALL_FREE_EXTRA_ARGS    (1 << 2)
-#define ZEND_CALL_HAS_SYMBOL_TABLE   (1 << 4)
-#define ZEND_CALL_CLOSURE            (1 << 5)
-#define ZEND_CALL_RELEASE_THIS       (1 << 6)
-#define ZEND_CALL_ALLOCATED          (1 << 7)
-#define ZEND_CALL_GENERATOR          (1 << 8)
-#define ZEND_CALL_DYNAMIC            (1 << 9)
-#define ZEND_CALL_FAKE_CLOSURE       (1 << 10)
-#define ZEND_CALL_SEND_ARG_BY_REF    (1 << 11)
-
-#define ZEND_CALL_INFO_SHIFT         16
+#define ZEND_CALL_HAS_THIS           IS_OBJECT_EX
+
+/* Top 16 bits of Z_TYPE_INFO(EX(This)) are used as call_info flags */
+#define ZEND_CALL_FUNCTION           (0 << 16)
+#define ZEND_CALL_CODE               (1 << 16)
+#define ZEND_CALL_NESTED             (0 << 17)
+#define ZEND_CALL_TOP                (1 << 17)
+#define ZEND_CALL_ALLOCATED          (1 << 18)
+#define ZEND_CALL_FREE_EXTRA_ARGS    (1 << 19)
+#define ZEND_CALL_HAS_SYMBOL_TABLE   (1 << 20)
+#define ZEND_CALL_RELEASE_THIS       (1 << 21)
+#define ZEND_CALL_CLOSURE            (1 << 22)
+#define ZEND_CALL_FAKE_CLOSURE       (1 << 23)
+#define ZEND_CALL_GENERATOR          (1 << 24)
+#define ZEND_CALL_DYNAMIC            (1 << 25)
+#define ZEND_CALL_SEND_ARG_BY_REF    (1 << 31)
+
+#define ZEND_CALL_NESTED_FUNCTION    (ZEND_CALL_FUNCTION | ZEND_CALL_NESTED)
+#define ZEND_CALL_NESTED_CODE        (ZEND_CALL_CODE | ZEND_CALL_NESTED)
+#define ZEND_CALL_TOP_FUNCTION       (ZEND_CALL_TOP | ZEND_CALL_FUNCTION)
+#define ZEND_CALL_TOP_CODE           (ZEND_CALL_CODE | ZEND_CALL_TOP)
 
 #define ZEND_CALL_INFO(call) \
-       (Z_TYPE_INFO((call)->This) >> ZEND_CALL_INFO_SHIFT)
+       Z_TYPE_INFO((call)->This)
 
 #define ZEND_CALL_KIND_EX(call_info) \
        (call_info & (ZEND_CALL_CODE | ZEND_CALL_TOP))
@@ -527,16 +526,12 @@ struct _zend_execute_data {
 #define ZEND_CALL_KIND(call) \
        ZEND_CALL_KIND_EX(ZEND_CALL_INFO(call))
 
-#define ZEND_SET_CALL_INFO(call, object, info) do { \
-               Z_TYPE_INFO((call)->This) = ((object) ? IS_OBJECT_EX : IS_UNDEF) | ((info) << ZEND_CALL_INFO_SHIFT); \
-       } while (0)
-
 #define ZEND_ADD_CALL_FLAG_EX(call_info, flag) do { \
-               call_info |= ((flag) << ZEND_CALL_INFO_SHIFT); \
+               call_info |= (flag); \
        } while (0)
 
 #define ZEND_DEL_CALL_FLAG_EX(call_info, flag) do { \
-               call_info &= ~((flag) << ZEND_CALL_INFO_SHIFT); \
+               call_info &= ~(flag); \
        } while (0)
 
 #define ZEND_ADD_CALL_FLAG(call, flag) do { \

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 6d13457a431b42af227b208f6fae66c8055cbb9e..4bd9d6932719927c96bc7eaccd6ff5ae77bdadcc 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -3855,13 +3855,14 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_string(zend_s
        }
 
        return zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC,
-               fbc, num_args, called_scope, NULL);
+               fbc, num_args, called_scope);
 }
 /* }}} */
 
 static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zval *function, uint32_t num_args) /* {{{ */
 {
        zend_function *fbc;
+       void *object_or_called_scope;
        zend_class_entry *called_scope;
        zend_object *object;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
@@ -3869,6 +3870,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zval *
        if (EXPECTED(Z_OBJ_HANDLER_P(function, get_closure)) &&
            EXPECTED(Z_OBJ_HANDLER_P(function, get_closure)(function, &called_scope, &fbc, &object) == SUCCESS)) {
 
+           object_or_called_scope = called_scope;
                if (fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
                        /* Delay closure destruction until its invocation */
                        GC_ADDREF(ZEND_CLOSURE_OBJECT(fbc));
@@ -3876,9 +3878,14 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zval *
                        if (fbc->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
                                call_info |= ZEND_CALL_FAKE_CLOSURE;
                        }
+                       if (object) {
+                               call_info |= ZEND_CALL_HAS_THIS;
+                               object_or_called_scope = object;
+                       }
                } else if (object) {
-                       call_info |= ZEND_CALL_RELEASE_THIS;
+                       call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                        GC_ADDREF(object); /* For $this pointer */
+                       object_or_called_scope = object;
                }
        } else {
                zend_throw_error(NULL, "Function name must be a string");
@@ -3890,15 +3897,14 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zval *
        }
 
        return zend_vm_stack_push_call_frame(call_info,
-               fbc, num_args, called_scope, object);
+               fbc, num_args, object_or_called_scope);
 }
 /* }}} */
 
 static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_array *function, uint32_t num_args) /* {{{ */
 {
        zend_function *fbc;
-       zend_class_entry *called_scope;
-       zend_object *object;
+       void *object_or_called_scope;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
        if (zend_hash_num_elements(function) == 2) {
@@ -3925,8 +3931,8 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar
                }
 
                if (Z_TYPE_P(obj) == IS_STRING) {
-                       object = NULL;
-                       called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+                       zend_class_entry *called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+
                        if (UNEXPECTED(called_scope == NULL)) {
                                return NULL;
                        }
@@ -3948,9 +3954,9 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar
                                        return NULL;
                                }
                        }
+                       object_or_called_scope = called_scope;
                } else {
-                       called_scope = Z_OBJCE_P(obj);
-                       object = Z_OBJ_P(obj);
+                       zend_object *object = Z_OBJ_P(obj);
 
                        fbc = Z_OBJ_HT_P(obj)->get_method(&object, Z_STR_P(method), NULL);
                        if (UNEXPECTED(fbc == NULL)) {
@@ -3961,10 +3967,11 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar
                        }
 
                        if ((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
-                               object = NULL;
+                               object_or_called_scope = object->ce;
                        } else {
-                               call_info |= ZEND_CALL_RELEASE_THIS;
+                               call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                                GC_ADDREF(object); /* For $this pointer */
+                               object_or_called_scope = object;
                        }
                }
        } else {
@@ -3977,7 +3984,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar
        }
 
        return zend_vm_stack_push_call_frame(call_info,
-               fbc, num_args, called_scope, object);
+               fbc, num_args, object_or_called_scope);
 }
 /* }}} */
 

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index effeec6577727ff1045d5cb69cb693d73c4195a1..3690dfdb4498a6fab0dc4ea2a5093fa04155035e 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -206,20 +206,15 @@ ZEND_API void zend_vm_stack_init_ex(size_t page_size);
 ZEND_API void zend_vm_stack_destroy(void);
 ZEND_API void* zend_vm_stack_extend(size_t size);
 
-static zend_always_inline void zend_vm_init_call_frame(zend_execute_data *call, uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object)
+static zend_always_inline void zend_vm_init_call_frame(zend_execute_data *call, uint32_t call_info, zend_function *func, uint32_t num_args, void *object_or_called_scope)
 {
        call->func = func;
-       if (object) {
-               Z_OBJ(call->This) = object;
-               ZEND_SET_CALL_INFO(call, 1, call_info);
-       } else {
-               Z_CE(call->This) = called_scope;
-               ZEND_SET_CALL_INFO(call, 0, call_info);
-       }
+       Z_PTR(call->This) = object_or_called_scope;
+       ZEND_CALL_INFO(call) = call_info;
        ZEND_CALL_NUM_ARGS(call) = num_args;
 }
 
-static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t used_stack, uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object)
+static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t used_stack, uint32_t call_info, zend_function *func, uint32_t num_args, void *object_or_called_scope)
 {
        zend_execute_data *call = (zend_execute_data*)EG(vm_stack_top);
 
@@ -228,11 +223,11 @@ static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(ui
        if (UNEXPECTED(used_stack > (size_t)(((char*)EG(vm_stack_end)) - (char*)call))) {
                call = (zend_execute_data*)zend_vm_stack_extend(used_stack);
                ZEND_ASSERT_VM_STACK_GLOBAL;
-               zend_vm_init_call_frame(call, call_info | ZEND_CALL_ALLOCATED, func, num_args, called_scope, object);
+               zend_vm_init_call_frame(call, call_info | ZEND_CALL_ALLOCATED, func, num_args, object_or_called_scope);
                return call;
        } else {
                EG(vm_stack_top) = (zval*)((char*)call + used_stack);
-               zend_vm_init_call_frame(call, call_info, func, num_args, called_scope, object);
+               zend_vm_init_call_frame(call, call_info, func, num_args, object_or_called_scope);
                return call;
        }
 }
@@ -247,12 +242,12 @@ static zend_always_inline uint32_t zend_vm_calc_used_stack(uint32_t num_args, ze
        return used_stack * sizeof(zval);
 }
 
-static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object)
+static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint32_t call_info, zend_function *func, uint32_t num_args, void *object_or_called_scope)
 {
        uint32_t used_stack = zend_vm_calc_used_stack(num_args, func);
 
        return zend_vm_stack_push_call_frame_ex(used_stack, call_info,
-               func, num_args, called_scope, object);
+               func, num_args, object_or_called_scope);
 }
 
 static zend_always_inline void zend_vm_stack_free_extra_args_ex(uint32_t call_info, zend_execute_data *call)

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index ab1ef9fa4941b1c2b979f9cc4c956432c428c0cc..794e6863dd73eda0aab9106fa74aa6a4929ab191 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -655,6 +655,8 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /
        zend_execute_data *call, dummy_execute_data;
        zend_fcall_info_cache fci_cache_local;
        zend_function *func;
+       uint32_t call_info;
+       void *object_or_called_scope;
 
        ZVAL_UNDEF(fci->retval);
 
@@ -727,11 +729,18 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /
        }
 
        func = fci_cache->function_handler;
-       fci->object = (func->common.fn_flags & ZEND_ACC_STATIC) ?
-               NULL : fci_cache->object;
+       if ((func->common.fn_flags & ZEND_ACC_STATIC) || !fci_cache->object) {
+               fci->object = NULL;
+               object_or_called_scope = fci_cache->called_scope;
+               call_info = ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC;
+       } else {
+               fci->object = fci_cache->object;
+               object_or_called_scope = fci->object;
+               call_info = ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC | ZEND_CALL_HAS_THIS;
+       }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC,
-               func, fci->param_count, fci_cache->called_scope, fci->object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               func, fci->param_count, object_or_called_scope);
 
        if (UNEXPECTED(func->common.fn_flags & ZEND_ACC_DEPRECATED)) {
                zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index a59d84cda7e2ecd2afc2dea8f98641170b2fa3e4..6b3f148b5b374fca0ad0eab02386a7e88d80adb7 100644 (file)
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -40,10 +40,7 @@ ZEND_API void zend_generator_restore_call_stack(zend_generator *generator) /* {{
                        (ZEND_CALL_INFO(call) & ~ZEND_CALL_ALLOCATED),
                        call->func,
                        ZEND_CALL_NUM_ARGS(call),
-                       (Z_TYPE(call->This) == IS_UNDEF) ?
-                               (zend_class_entry*)Z_OBJ(call->This) : NULL,
-                       (Z_TYPE(call->This) != IS_UNDEF) ?
-                               Z_OBJ(call->This) : NULL);
+                       Z_PTR(call->This));
                memcpy(((zval*)new_call) + ZEND_CALL_FRAME_SLOT, ((zval*)call) + ZEND_CALL_FRAME_SLOT, ZEND_CALL_NUM_ARGS(call) * sizeof(zval));
                new_call->prev_execute_data = prev_call;
                prev_call = new_call;

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index a5ca56e0cf67e87b618cecc3c6f14cc3ce5a92c5..3f6e1c1402b7199f3c8ef2cfa5b81d135c3de2e7 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -201,7 +201,6 @@ struct _zval_struct {
                                zend_uchar    type,                     /* active type */
                                zend_uchar    type_flags,
                                union {
-                                       uint16_t  call_info;    /* call info for EX(This) */
                                        uint16_t  extra;        /* not further specified */
                                } u)
                } v;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index e975a92014f2ecedb13563e4f36cb6b6179dbaed..21d5651cb8d80704cebaad7ed33023a37b5c5843 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -3427,27 +3427,29 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV,
                FREE_OP2();
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
                FREE_OP1();
 
                if ((OP1_TYPE & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (OP1_TYPE & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (OP1_TYPE == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
                        FREE_OP1();
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3459,7 +3461,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR,
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -3560,33 +3562,34 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR,
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       ZEND_VM_C_GOTO(check_parent_and_self);
                }
-       }
-
-       if (OP1_TYPE == IS_UNUSED) {
+       } else {
+ZEND_VM_C_LABEL(check_parent_and_self):
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (OP1_TYPE == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3614,7 +3617,7 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
                CACHE_PTR(opline->result.num, fbc);
        }
        call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3686,8 +3689,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
        zend_fcall_info_cache fcc;
        char *error = NULL;
        zend_function *func;
-       zend_class_entry *called_scope;
-       zend_object *object;
+       void *object_or_called_scope;
        zend_execute_data *call;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
@@ -3695,8 +3697,6 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
        function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
        if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
                func = fcc.function_handler;
-               called_scope = fcc.called_scope;
-               object = fcc.object;
                if (error) {
                        efree(error);
                        /* This is the only soft error is_callable() can generate */
@@ -3706,6 +3706,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
                                HANDLE_EXCEPTION();
                        }
                }
+               object_or_called_scope = fcc.called_scope;
                if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        /* Delay closure destruction until its invocation */
                        GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
@@ -3713,18 +3714,22 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
                        if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
                                call_info |= ZEND_CALL_FAKE_CLOSURE;
                        }
-               } else if (object) {
-                       call_info |= ZEND_CALL_RELEASE_THIS;
-                       GC_ADDREF(object); /* For $this pointer */
+                       if (fcc.object) {
+                               object_or_called_scope = fcc.object;
+                               call_info |= ZEND_CALL_HAS_THIS;
+                       }
+               } else if (fcc.object) {
+                       GC_ADDREF(fcc.object); /* For $this pointer */
+                       object_or_called_scope = fcc.object;
+                       call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                }
 
                FREE_OP2();
                if ((OP2_TYPE & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
                        if (call_info & ZEND_CALL_CLOSURE) {
                                zend_object_release(ZEND_CLOSURE_OBJECT(func));
-                       }
-                       if (call_info & ZEND_CALL_RELEASE_THIS) {
-                               zend_object_release(object);
+                       } else if (call_info & ZEND_CALL_RELEASE_THIS) {
+                               zend_object_release(fcc.object);
                        }
                        HANDLE_EXCEPTION();
                }
@@ -3740,12 +3745,11 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
                        HANDLE_EXCEPTION();
                }
                func = (zend_function*)&zend_pass_function;
-               called_scope = NULL;
-               object = NULL;
+               object_or_called_scope = NULL;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               func, opline->extended_value, called_scope, object);
+               func, opline->extended_value, object_or_called_scope);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3778,7 +3782,7 @@ ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
        }
 
        call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3809,7 +3813,7 @@ ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT)
 
        call = zend_vm_stack_push_call_frame_ex(
                opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -4298,7 +4302,7 @@ ZEND_VM_HANDLER(41, ZEND_GENERATOR_CREATE, ANY, ANY)
                gen_execute_data->return_value = (zval*)generator;
                call_info = Z_TYPE_INFO(EX(This));
                if ((call_info & Z_TYPE_MASK) == IS_OBJECT
-                && (!(call_info & ((ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS) << ZEND_CALL_INFO_SHIFT))
+                && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
                         /* Bug #72523 */
                        || UNEXPECTED(zend_execute_ex != execute_ex))) {
                        ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
@@ -4916,13 +4920,12 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM)
                zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
                if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_CLOSURE) {
                        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(call)->func));
-               }
-               if (Z_TYPE(EX(call)->This) == IS_OBJECT) {
+               } else if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_RELEASE_THIS) {
                        OBJ_RELEASE(Z_OBJ(EX(call)->This));
                }
                EX(call)->func = (zend_function*)&zend_pass_function;
                Z_OBJ(EX(call)->This) = NULL;
-               ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS);
+               ZEND_CALL_INFO(EX(call)) &= ~(ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS);
                FREE_UNFETCHED_OP2();
        } else {
                uint32_t arg_num;
@@ -5287,17 +5290,16 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N
                /* Perform a dummy function call */
                call = zend_vm_stack_push_call_frame(
                        ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
-                       opline->extended_value, NULL, NULL);
+                       opline->extended_value, NULL);
        } else {
                if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
                        init_func_run_time_cache(&constructor->op_array);
                }
                /* We are not handling overloaded classes right now */
                call = zend_vm_stack_push_call_frame(
-                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS,
+                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
                        constructor,
                        opline->extended_value,
-                       ce,
                        Z_OBJ_P(result));
                Z_ADDREF_P(result);
        }
@@ -5704,10 +5706,10 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
 
                new_op_array->scope = EX(func)->op_array.scope;
 
-               call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+               call = zend_vm_stack_push_call_frame(
+                   (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
                        (zend_function*)new_op_array, 0,
-                       Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL,
-                       Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL);
+                       Z_PTR(EX(This)));
 
                if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
                        call->symbol_table = EX(symbol_table);

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index ad4f978ad1d7101a300f60b3aa801265a208a72c..a84ae4ec7543ce398ba70e5453003f10e665984e 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1451,7 +1451,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(
                gen_execute_data->return_value = (zval*)generator;
                call_info = Z_TYPE_INFO(EX(This));
                if ((call_info & Z_TYPE_MASK) == IS_OBJECT
-                && (!(call_info & ((ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS) << ZEND_CALL_INFO_SHIFT))
+                && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
                         /* Bug #72523 */
                        || UNEXPECTED(zend_execute_ex != execute_ex))) {
                        ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
@@ -1668,13 +1668,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O
                zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
                if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_CLOSURE) {
                        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(call)->func));
-               }
-               if (Z_TYPE(EX(call)->This) == IS_OBJECT) {
+               } else if (ZEND_CALL_INFO(EX(call)) & ZEND_CALL_RELEASE_THIS) {
                        OBJ_RELEASE(Z_OBJ(EX(call)->This));
                }
                EX(call)->func = (zend_function*)&zend_pass_function;
                Z_OBJ(EX(call)->This) = NULL;
-               ZEND_SET_CALL_INFO(EX(call), 0, ZEND_CALL_INFO(EX(call)) & ~ZEND_CALL_RELEASE_THIS);
+               ZEND_CALL_INFO(EX(call)) &= ~(ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS);
                FREE_UNFETCHED_OP(opline->op2_type, opline->op2.var);
        } else {
                uint32_t arg_num;
@@ -2299,7 +2298,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME
                CACHE_PTR(opline->result.num, fbc);
        }
        call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -2388,7 +2387,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_N
        }
 
        call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -2419,7 +2418,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CO
 
        call = zend_vm_stack_push_call_frame_ex(
                opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, NULL, NULL);
+               fbc, opline->extended_value, NULL);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -3460,10 +3459,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN
 
                new_op_array->scope = EX(func)->op_array.scope;
 
-               call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+               call = zend_vm_stack_push_call_frame(
+                   (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
                        (zend_function*)new_op_array, 0,
-                       Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL,
-                       Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL);
+                       Z_PTR(EX(This)));
 
                if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
                        call->symbol_table = EX(symbol_table);
@@ -5412,26 +5411,28 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CONST == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -5443,7 +5444,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -5544,33 +5545,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_CONST == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_CONST == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -5585,8 +5587,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
        zend_fcall_info_cache fcc;
        char *error = NULL;
        zend_function *func;
-       zend_class_entry *called_scope;
-       zend_object *object;
+       void *object_or_called_scope;
        zend_execute_data *call;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
@@ -5594,8 +5595,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
        function_name = RT_CONSTANT(opline, opline->op2);
        if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
                func = fcc.function_handler;
-               called_scope = fcc.called_scope;
-               object = fcc.object;
                if (error) {
                        efree(error);
                        /* This is the only soft error is_callable() can generate */
@@ -5605,6 +5604,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
                                HANDLE_EXCEPTION();
                        }
                }
+               object_or_called_scope = fcc.called_scope;
                if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        /* Delay closure destruction until its invocation */
                        GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
@@ -5612,17 +5612,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
                        if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
                                call_info |= ZEND_CALL_FAKE_CLOSURE;
                        }
-               } else if (object) {
-                       call_info |= ZEND_CALL_RELEASE_THIS;
-                       GC_ADDREF(object); /* For $this pointer */
+                       if (fcc.object) {
+                               object_or_called_scope = fcc.object;
+                               call_info |= ZEND_CALL_HAS_THIS;
+                       }
+               } else if (fcc.object) {
+                       GC_ADDREF(fcc.object); /* For $this pointer */
+                       object_or_called_scope = fcc.object;
+                       call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                }
 
                if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
                        if (call_info & ZEND_CALL_CLOSURE) {
                                zend_object_release(ZEND_CLOSURE_OBJECT(func));
-                       }
-                       if (call_info & ZEND_CALL_RELEASE_THIS) {
-                               zend_object_release(object);
+                       } else if (call_info & ZEND_CALL_RELEASE_THIS) {
+                               zend_object_release(fcc.object);
                        }
                        HANDLE_EXCEPTION();
                }
@@ -5638,12 +5642,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
                        HANDLE_EXCEPTION();
                }
                func = (zend_function*)&zend_pass_function;
-               called_scope = NULL;
-               object = NULL;
+               object_or_called_scope = NULL;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               func, opline->extended_value, called_scope, object);
+               func, opline->extended_value, object_or_called_scope);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -7659,26 +7662,28 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
                zval_ptr_dtor_nogc(free_op2);
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CONST == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -7690,7 +7695,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -7791,33 +7796,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_CONST == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_CONST == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -7832,8 +7838,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
        zend_fcall_info_cache fcc;
        char *error = NULL;
        zend_function *func;
-       zend_class_entry *called_scope;
-       zend_object *object;
+       void *object_or_called_scope;
        zend_execute_data *call;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
@@ -7841,8 +7846,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
        function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
                func = fcc.function_handler;
-               called_scope = fcc.called_scope;
-               object = fcc.object;
                if (error) {
                        efree(error);
                        /* This is the only soft error is_callable() can generate */
@@ -7852,6 +7855,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
                                HANDLE_EXCEPTION();
                        }
                }
+               object_or_called_scope = fcc.called_scope;
                if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        /* Delay closure destruction until its invocation */
                        GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
@@ -7859,18 +7863,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
                        if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
                                call_info |= ZEND_CALL_FAKE_CLOSURE;
                        }
-               } else if (object) {
-                       call_info |= ZEND_CALL_RELEASE_THIS;
-                       GC_ADDREF(object); /* For $this pointer */
+                       if (fcc.object) {
+                               object_or_called_scope = fcc.object;
+                               call_info |= ZEND_CALL_HAS_THIS;
+                       }
+               } else if (fcc.object) {
+                       GC_ADDREF(fcc.object); /* For $this pointer */
+                       object_or_called_scope = fcc.object;
+                       call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                }
 
                zval_ptr_dtor_nogc(free_op2);
                if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
                        if (call_info & ZEND_CALL_CLOSURE) {
                                zend_object_release(ZEND_CLOSURE_OBJECT(func));
-                       }
-                       if (call_info & ZEND_CALL_RELEASE_THIS) {
-                               zend_object_release(object);
+                       } else if (call_info & ZEND_CALL_RELEASE_THIS) {
+                               zend_object_release(fcc.object);
                        }
                        HANDLE_EXCEPTION();
                }
@@ -7886,12 +7894,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
                        HANDLE_EXCEPTION();
                }
                func = (zend_function*)&zend_pass_function;
-               called_scope = NULL;
-               object = NULL;
+               object_or_called_scope = NULL;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               func, opline->extended_value, called_scope, object);
+               func, opline->extended_value, object_or_called_scope);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -8841,7 +8848,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -8942,33 +8949,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_CONST == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_CONST == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -9077,17 +9085,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(
                /* Perform a dummy function call */
                call = zend_vm_stack_push_call_frame(
                        ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
-                       opline->extended_value, NULL, NULL);
+                       opline->extended_value, NULL);
        } else {
                if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
                        init_func_run_time_cache(&constructor->op_array);
                }
                /* We are not handling overloaded classes right now */
                call = zend_vm_stack_push_call_frame(
-                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS,
+                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
                        constructor,
                        opline->extended_value,
-                       ce,
                        Z_OBJ_P(result));
                Z_ADDREF_P(result);
        }
@@ -10602,26 +10609,28 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CONST == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -10633,7 +10642,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -10734,33 +10743,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_CONST == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_CONST == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -10775,8 +10785,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
        zend_fcall_info_cache fcc;
        char *error = NULL;
        zend_function *func;
-       zend_class_entry *called_scope;
-       zend_object *object;
+       void *object_or_called_scope;
        zend_execute_data *call;
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
@@ -10784,8 +10793,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
        function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
                func = fcc.function_handler;
-               called_scope = fcc.called_scope;
-               object = fcc.object;
                if (error) {
                        efree(error);
                        /* This is the only soft error is_callable() can generate */
@@ -10795,6 +10802,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
                                HANDLE_EXCEPTION();
                        }
                }
+               object_or_called_scope = fcc.called_scope;
                if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        /* Delay closure destruction until its invocation */
                        GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
@@ -10802,17 +10810,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
                        if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
                                call_info |= ZEND_CALL_FAKE_CLOSURE;
                        }
-               } else if (object) {
-                       call_info |= ZEND_CALL_RELEASE_THIS;
-                       GC_ADDREF(object); /* For $this pointer */
+                       if (fcc.object) {
+                               object_or_called_scope = fcc.object;
+                               call_info |= ZEND_CALL_HAS_THIS;
+                       }
+               } else if (fcc.object) {
+                       GC_ADDREF(fcc.object); /* For $this pointer */
+                       object_or_called_scope = fcc.object;
+                       call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
                }
 
                if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
                        if (call_info & ZEND_CALL_CLOSURE) {
                                zend_object_release(ZEND_CLOSURE_OBJECT(func));
-                       }
-                       if (call_info & ZEND_CALL_RELEASE_THIS) {
-                               zend_object_release(object);
+                       } else if (call_info & ZEND_CALL_RELEASE_THIS) {
+                               zend_object_release(fcc.object);
                        }
                        HANDLE_EXCEPTION();
                }
@@ -10828,12 +10840,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
                        HANDLE_EXCEPTION();
                }
                func = (zend_function*)&zend_pass_function;
-               called_scope = NULL;
-               object = NULL;
+               object_or_called_scope = NULL;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               func, opline->extended_value, called_scope, object);
+               func, opline->extended_value, object_or_called_scope);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -12919,10 +12930,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
 
                new_op_array->scope = EX(func)->op_array.scope;
 
-               call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+               call = zend_vm_stack_push_call_frame(
+                   (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
                        (zend_function*)new_op_array, 0,
-                       Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL,
-                       Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL);
+                       Z_PTR(EX(This)));
 
                if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
                        call->symbol_table = EX(symbol_table);
@@ -14337,27 +14348,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
                zval_ptr_dtor_nogc(free_op1);
 
                if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
                        zval_ptr_dtor_nogc(free_op1);
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -15972,27 +15985,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T
                zval_ptr_dtor_nogc(free_op2);
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
                zval_ptr_dtor_nogc(free_op1);
 
                if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
                        zval_ptr_dtor_nogc(free_op1);
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -17635,27 +17650,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
                zval_ptr_dtor_nogc(free_op1);
 
                if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
                        zval_ptr_dtor_nogc(free_op1);
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -24510,7 +24527,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -24611,33 +24628,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_VAR == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_VAR == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -27209,7 +27227,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -27310,33 +27328,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_VAR == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_VAR == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -28889,7 +28908,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -28990,33 +29009,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_VAR == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_VAR == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -29125,17 +29145,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZE
                /* Perform a dummy function call */
                call = zend_vm_stack_push_call_frame(
                        ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
-                       opline->extended_value, NULL, NULL);
+                       opline->extended_value, NULL);
        } else {
                if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
                        init_func_run_time_cache(&constructor->op_array);
                }
                /* We are not handling overloaded classes right now */
                call = zend_vm_stack_push_call_frame(
-                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS,
+                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
                        constructor,
                        opline->extended_value,
-                       ce,
                        Z_OBJ_P(result));
                Z_ADDREF_P(result);
        }
@@ -31617,7 +31636,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -31718,33 +31737,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_VAR == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_VAR == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -33889,26 +33909,28 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_UNUSED == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -33920,7 +33942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -34021,33 +34043,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_UNUSED == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_UNUSED == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -35837,26 +35860,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T
                zval_ptr_dtor_nogc(free_op2);
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_UNUSED == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -35868,7 +35893,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -35969,33 +35994,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_UNUSED == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_UNUSED == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -36400,7 +36426,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -36501,33 +36527,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_UNUSED == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_UNUSED == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -36636,17 +36663,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER
                /* Perform a dummy function call */
                call = zend_vm_stack_push_call_frame(
                        ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
-                       opline->extended_value, NULL, NULL);
+                       opline->extended_value, NULL);
        } else {
                if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
                        init_func_run_time_cache(&constructor->op_array);
                }
                /* We are not handling overloaded classes right now */
                call = zend_vm_stack_push_call_frame(
-                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS,
+                       ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
                        constructor,
                        opline->extended_value,
-                       ce,
                        Z_OBJ_P(result));
                Z_ADDREF_P(result);
        }
@@ -38430,26 +38456,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_UNUSED == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -38461,7 +38489,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        USE_OPLINE
        zval *function_name;
        zend_class_entry *ce;
-       zend_object *object;
+       uint32_t call_info;
        zend_function *fbc;
        zend_execute_data *call;
 
@@ -38562,33 +38590,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
                }
        }
 
-       object = NULL;
        if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
                if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
-                       object = Z_OBJ(EX(This));
-                       ce = object->ce;
+                       ce = (zend_class_entry*)Z_OBJ(EX(This));
+                       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
                } else {
                        zend_non_static_method_call(fbc);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
+                       goto check_parent_and_self;
                }
-       }
-
-       if (IS_UNUSED == IS_UNUSED) {
+       } else {
+check_parent_and_self:
                /* previous opcode is ZEND_FETCH_CLASS */
-               if ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
-                   (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
+               if (IS_UNUSED == IS_UNUSED
+                && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
+                    (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
                        if (Z_TYPE(EX(This)) == IS_OBJECT) {
                                ce = Z_OBJCE(EX(This));
                        } else {
                                ce = Z_CE(EX(This));
                        }
                }
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        }
 
-       call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->extended_value, ce, object);
+       call = zend_vm_stack_push_call_frame(call_info,
+               fbc, opline->extended_value, ce);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -39936,10 +39965,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
 
                new_op_array->scope = EX(func)->op_array.scope;
 
-               call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+               call = zend_vm_stack_push_call_frame(
+                   (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
                        (zend_function*)new_op_array, 0,
-                       Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL,
-                       Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL);
+                       Z_PTR(EX(This)));
 
                if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
                        call->symbol_table = EX(symbol_table);
@@ -43870,26 +43899,28 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CV == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -47977,26 +48008,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA
                zval_ptr_dtor_nogc(free_op2);
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CV == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -54050,26 +54083,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA
 
        }
 
-       call_info = ZEND_CALL_NESTED_FUNCTION;
+       call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
        if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
-               obj = NULL;
 
                if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
                        HANDLE_EXCEPTION();
                }
+               /* call static method */
+               obj = (zend_object*)called_scope;
+               call_info = ZEND_CALL_NESTED_FUNCTION;
        } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
-               /* CV may be changed indirectly (e.g. when it's a reference) */
-               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_RELEASE_THIS;
                if (IS_CV == IS_CV) {
                        GC_ADDREF(obj); /* For $this pointer */
                } else if (free_op1 != object) {
                        GC_ADDREF(obj); /* For $this pointer */
 
                }
+               /* CV may be changed indirectly (e.g. when it's a reference) */
+               call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
        }
 
        call = zend_vm_stack_push_call_frame(call_info,
-               fbc, opline->extended_value, called_scope, obj);
+               fbc, opline->extended_value, obj);
        call->prev_execute_data = EX(call);
        EX(call) = call;
 
@@ -65456,13 +65491,22 @@ zend_leave_helper_SPEC_LABEL:
 ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
 {
        zend_execute_data *execute_data;
+       void *object_or_called_scope;
+       uint32_t call_info;
 
        if (EG(exception) != NULL) {
                return;
        }
 
-       execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
-               (zend_function*)op_array, 0, zend_get_called_scope(EG(current_execute_data)), zend_get_this_object(EG(current_execute_data)));
+       object_or_called_scope = zend_get_this_object(EG(current_execute_data));
+       if (EXPECTED(!object_or_called_scope)) {
+               object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
+               call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
+       } else {
+               call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
+       }
+       execute_data = zend_vm_stack_push_call_frame(call_info,
+               (zend_function*)op_array, 0, object_or_called_scope);
        if (EG(current_execute_data)) {
                execute_data->symbol_table = zend_rebuild_symbol_table();
        } else {

diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl
index 30f0017cbdd9d8ee05e95dfebbb195e9ca94a800..5e6e98bb24e76ba7d19b938c3e1193772e2837ec 100644 (file)
--- a/Zend/zend_vm_execute.skl
+++ b/Zend/zend_vm_execute.skl
@@ -24,13 +24,22 @@ ZEND_API void {%EXECUTOR_NAME%}_ex(zend_execute_data *ex)
 ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value)
 {
        zend_execute_data *execute_data;
+       void *object_or_called_scope;
+       uint32_t call_info;
 
        if (EG(exception) != NULL) {
                return;
        }
 
-       execute_data = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
-               (zend_function*)op_array, 0, zend_get_called_scope(EG(current_execute_data)), zend_get_this_object(EG(current_execute_data)));
+       object_or_called_scope = zend_get_this_object(EG(current_execute_data));
+       if (EXPECTED(!object_or_called_scope)) {
+               object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
+               call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
+       } else {
+               call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
+       }
+       execute_data = zend_vm_stack_push_call_frame(call_info,
+               (zend_function*)op_array, 0, object_or_called_scope);
        if (EG(current_execute_data)) {
                execute_data->symbol_table = zend_rebuild_symbol_table();
        } else {

diff --git a/sapi/fpm/fpm/fpm_php_trace.c b/sapi/fpm/fpm/fpm_php_trace.c
index 3174eef2fbe12338069f8cccd72ce90b2c600e51..cfdcf6509457b68594db0f054fb9ba930966c036 100644 (file)
--- a/sapi/fpm/fpm/fpm_php_trace.c
+++ b/sapi/fpm/fpm/fpm_php_trace.c
@@ -99,9 +99,9 @@ static int fpm_php_trace_dump(struct fpm_child_s *child, FILE *slowlog) /* {{{ *
                                        return -1;
                                }
 
-                               if (ZEND_CALL_KIND_EX((*call_info) >> ZEND_CALL_INFO_SHIFT) == ZEND_CALL_TOP_CODE) {
+                               if (ZEND_CALL_KIND_EX(*call_info) == ZEND_CALL_TOP_CODE) {
                                        return 0;
-                               } else if (ZEND_CALL_KIND_EX(*(call_info) >> ZEND_CALL_INFO_SHIFT) == ZEND_CALL_NESTED_CODE) {
+                               } else if (ZEND_CALL_KIND_EX(*call_info) == ZEND_CALL_NESTED_CODE) {
                                        memcpy(buf, "[INCLUDE_OR_EVAL]", sizeof("[INCLUDE_OR_EVAL]"));
                                } else {
                                        ZEND_ASSERT(0);