VM refactoring, to avoid passing "execute_data" into helper functions that can access...

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 1174c13401fc829b4e95ae9ae75f8faf4c81da74..715808632ec4912a7b63d12adfbc6310a4c7c59b 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -45,6 +45,46 @@
 /* Virtual current working directory support */
 #include "zend_virtual_cwd.h"
 
+#ifdef HAVE_GCC_GLOBAL_REGS
+# if defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(i386)
+#  define ZEND_VM_FP_GLOBAL_REG "%esi"
+#  define ZEND_VM_IP_GLOBAL_REG "%edi"
+# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__x86_64__)
+#  define ZEND_VM_FP_GLOBAL_REG "%r14"
+#  define ZEND_VM_IP_GLOBAL_REG "%r15"
+# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__powerpc64__)
+#  define ZEND_VM_FP_GLOBAL_REG "r28"
+#  define ZEND_VM_IP_GLOBAL_REG "r29"
+# elif defined(__IBMC__) && ZEND_GCC_VERSION >= 4002 && defined(__powerpc64__)
+#  define ZEND_VM_FP_GLOBAL_REG "r28"
+#  define ZEND_VM_IP_GLOBAL_REG "r29"
+# endif
+#endif
+
+#if defined(ZEND_VM_FP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
+# pragma GCC diagnostic ignored "-Wvolatile-register-var"
+  register zend_execute_data* volatile execute_data __asm__(ZEND_VM_FP_GLOBAL_REG);
+# pragma GCC diagnostic warning "-Wvolatile-register-var"
+# define EXECUTE_DATA_D     void
+# define EXECUTE_DATA_C
+# define EXECUTE_DATA_DC
+# define EXECUTE_DATA_CC
+# define NO_EXECUTE_DATA_CC
+#else
+# define EXECUTE_DATA_D     zend_execute_data* execute_data
+# define EXECUTE_DATA_C     execute_data
+# define EXECUTE_DATA_DC    , EXECUTE_DATA_D
+# define EXECUTE_DATA_CC    , EXECUTE_DATA_C
+# define NO_EXECUTE_DATA_CC , NULL
+#endif
+
+#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
+# pragma GCC diagnostic ignored "-Wvolatile-register-var"
+  register const zend_op* volatile opline __asm__(ZEND_VM_IP_GLOBAL_REG);
+# pragma GCC diagnostic warning "-Wvolatile-register-var"
+#else
+#endif
+
 #define _CONST_CODE  0
 #define _TMP_CODE    1
 #define _VAR_CODE    2
@@ -53,21 +93,16 @@
 
 typedef int (ZEND_FASTCALL *incdec_t)(zval *);
 
-#define get_zval_ptr(op_type, node, ex, should_free, type) _get_zval_ptr(op_type, node, ex, should_free, type)
-#define get_zval_ptr_deref(op_type, node, ex, should_free, type) _get_zval_ptr_deref(op_type, node, ex, should_free, type)
-#define get_zval_ptr_r(op_type, node, ex, should_free) _get_zval_ptr_r(op_type, node, ex, should_free)
-#define get_zval_ptr_r_deref(op_type, node, ex, should_free) _get_zval_ptr_r_deref(op_type, node, ex, should_free)
-#define get_zval_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_undef(op_type, node, ex, should_free, type)
-#define get_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
-#define get_zval_ptr_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
-#define get_obj_zval_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr(op_type, node, ex, should_free, type)
-#define get_obj_zval_ptr_undef(op_type, node, ex, should_free, type) _get_obj_zval_ptr_undef(op_type, node, ex, should_free, type)
-#define get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type)
-
-/* Prototypes */
-static void zend_extension_statement_handler(const zend_extension *extension, zend_execute_data *frame);
-static void zend_extension_fcall_begin_handler(const zend_extension *extension, zend_execute_data *frame);
-static void zend_extension_fcall_end_handler(const zend_extension *extension, zend_execute_data *frame);
+#define get_zval_ptr(op_type, node, should_free, type) _get_zval_ptr(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_zval_ptr_deref(op_type, node, should_free, type) _get_zval_ptr_deref(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_zval_ptr_r(op_type, node, should_free) _get_zval_ptr_r(op_type, node, should_free EXECUTE_DATA_CC)
+#define get_zval_ptr_r_deref(op_type, node, should_free) _get_zval_ptr_r_deref(op_type, node, should_free EXECUTE_DATA_CC)
+#define get_zval_ptr_undef(op_type, node, should_free, type) _get_zval_ptr_undef(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_zval_ptr_ptr(op_type, node, should_free, type) _get_zval_ptr_ptr(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_zval_ptr_ptr_undef(op_type, node, should_free, type) _get_zval_ptr_ptr(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_obj_zval_ptr(op_type, node, should_free, type) _get_obj_zval_ptr(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_obj_zval_ptr_undef(op_type, node, should_free, type) _get_obj_zval_ptr_undef(op_type, node, should_free, type EXECUTE_DATA_CC)
+#define get_obj_zval_ptr_ptr(op_type, node, should_free, type) _get_obj_zval_ptr_ptr(op_type, node, should_free, type EXECUTE_DATA_CC)
 
 #define RETURN_VALUE_USED(opline) ((opline)->result_type != IS_UNUSED)
 
@@ -181,7 +216,7 @@ ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute
        return EX_VAR(var);
 }
 
-static zend_always_inline zval *_get_zval_ptr_tmp(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_tmp(uint32_t var, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
        *should_free = ret;
@@ -191,7 +226,7 @@ static zend_always_inline zval *_get_zval_ptr_tmp(uint32_t var, const zend_execu
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_var(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_var(uint32_t var, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
@@ -199,7 +234,7 @@ static zend_always_inline zval *_get_zval_ptr_var(uint32_t var, const zend_execu
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_var_deref(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_var_deref(uint32_t var, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
@@ -208,25 +243,25 @@ static zend_always_inline zval *_get_zval_ptr_var_deref(uint32_t var, const zend
        return ret;
 }
 
-static zend_never_inline ZEND_COLD void zval_undefined_cv(uint32_t var, const zend_execute_data *execute_data)
+static zend_never_inline ZEND_COLD void zval_undefined_cv(uint32_t var EXECUTE_DATA_DC)
 {
        zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
        zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
 }
 
-static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int type, const zend_execute_data *execute_data)
+static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int type EXECUTE_DATA_DC)
 {
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_UNSET:
-                       zval_undefined_cv(var, execute_data);
+                       zval_undefined_cv(var EXECUTE_DATA_CC);
                        /* break missing intentionally */
                case BP_VAR_IS:
                        ptr = &EG(uninitialized_zval);
                        break;
                case BP_VAR_RW:
-                       zval_undefined_cv(var, execute_data);
+                       zval_undefined_cv(var EXECUTE_DATA_CC);
                        /* break missing intentionally */
                case BP_VAR_W:
                        ZVAL_NULL(ptr);
@@ -235,107 +270,107 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int
        return ptr;
 }
 
-static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, uint32_t var EXECUTE_DATA_DC)
 {
-       zval_undefined_cv(var, execute_data);
+       zval_undefined_cv(var EXECUTE_DATA_CC);
        return &EG(uninitialized_zval);
 }
 
-static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, uint32_t var EXECUTE_DATA_DC)
 {
-       zval_undefined_cv(var, execute_data);
+       zval_undefined_cv(var EXECUTE_DATA_CC);
        return &EG(uninitialized_zval);
 }
 
-static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, uint32_t var EXECUTE_DATA_DC)
 {
        ZVAL_NULL(ptr);
-       zval_undefined_cv(var, execute_data);
+       zval_undefined_cv(var EXECUTE_DATA_CC);
        return ptr;
 }
 
-static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, uint32_t var EXECUTE_DATA_DC)
 {
        ZVAL_NULL(ptr);
        return ptr;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv(const zend_execute_data *execute_data, uint32_t var, int type)
+static zend_always_inline zval *_get_zval_ptr_cv(uint32_t var, int type EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup(ret, var, type, execute_data);
+               return _get_zval_cv_lookup(ret, var, type EXECUTE_DATA_CC);
        }
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_undef(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_undef(uint32_t var EXECUTE_DATA_DC)
 {
        return EX_VAR(var);
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref(const zend_execute_data *execute_data, uint32_t var, int type)
+static zend_always_inline zval *_get_zval_ptr_cv_deref(uint32_t var, int type EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup(ret, var, type, execute_data);
+               return _get_zval_cv_lookup(ret, var, type EXECUTE_DATA_CC);
        }
        ZVAL_DEREF(ret);
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_R(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_R(ret, var EXECUTE_DATA_CC);
        }
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_R(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_R(ret, var EXECUTE_DATA_CC);
        }
        ZVAL_DEREF(ret);
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var EXECUTE_DATA_CC);
        }
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var EXECUTE_DATA_CC);
        }
        ZVAL_DEREF(ret);
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
@@ -343,169 +378,169 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_exec
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_RW(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_RW(ret, var EXECUTE_DATA_CC);
        }
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
-               return _get_zval_cv_lookup_BP_VAR_RW(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_RW(ret, var EXECUTE_DATA_CC);
        }
        ZVAL_DEREF(ret);
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
-               return _get_zval_cv_lookup_BP_VAR_W(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_W(ret, var EXECUTE_DATA_CC);
        }
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_W(uint32_t var EXECUTE_DATA_DC)
 {
        return EX_VAR(var);
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_RW(uint32_t var EXECUTE_DATA_DC)
 {
        return EX_VAR(var);
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_UNSET(uint32_t var EXECUTE_DATA_DC)
 {
        return EX_VAR(var);
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(uint32_t var EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
-               return _get_zval_cv_lookup_BP_VAR_W(ret, var, execute_data);
+               return _get_zval_cv_lookup_BP_VAR_W(ret, var EXECUTE_DATA_CC);
        }
        ZVAL_DEREF(ret);
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
                if (op_type == IS_TMP_VAR) {
-                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+                       return _get_zval_ptr_tmp(node.var, should_free EXECUTE_DATA_CC);
                } else {
                        ZEND_ASSERT(op_type == IS_VAR);
-                       return _get_zval_ptr_var(node.var, execute_data, should_free);
+                       return _get_zval_ptr_var(node.var, should_free EXECUTE_DATA_CC);
                }
        } else {
                *should_free = NULL;
                if (op_type == IS_CONST) {
                        return EX_CONSTANT(node);
                } else if (op_type == IS_CV) {
-                       return _get_zval_ptr_cv(execute_data, node.var, type);
+                       return _get_zval_ptr_cv(node.var, type EXECUTE_DATA_CC);
                } else {
                        return NULL;
                }
        }
 }
 
-static zend_always_inline zval *_get_zval_ptr_r(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_r(int op_type, znode_op node, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
                if (op_type == IS_TMP_VAR) {
-                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+                       return _get_zval_ptr_tmp(node.var, should_free EXECUTE_DATA_CC);
                } else {
                        ZEND_ASSERT(op_type == IS_VAR);
-                       return _get_zval_ptr_var(node.var, execute_data, should_free);
+                       return _get_zval_ptr_var(node.var, should_free EXECUTE_DATA_CC);
                }
        } else {
                *should_free = NULL;
                if (op_type == IS_CONST) {
                        return EX_CONSTANT(node);
                } else if (op_type == IS_CV) {
-                       return _get_zval_ptr_cv_BP_VAR_R(execute_data, node.var);
+                       return _get_zval_ptr_cv_BP_VAR_R(node.var EXECUTE_DATA_CC);
                } else {
                        return NULL;
                }
        }
 }
 
-static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
                if (op_type == IS_TMP_VAR) {
-                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+                       return _get_zval_ptr_tmp(node.var, should_free EXECUTE_DATA_CC);
                } else {
                        ZEND_ASSERT(op_type == IS_VAR);
-                       return _get_zval_ptr_var_deref(node.var, execute_data, should_free);
+                       return _get_zval_ptr_var_deref(node.var, should_free EXECUTE_DATA_CC);
                }
        } else {
                *should_free = NULL;
                if (op_type == IS_CONST) {
                        return EX_CONSTANT(node);
                } else if (op_type == IS_CV) {
-                       return _get_zval_ptr_cv_deref(execute_data, node.var, type);
+                       return _get_zval_ptr_cv_deref(node.var, type EXECUTE_DATA_CC);
                } else {
                        return NULL;
                }
        }
 }
 
-static zend_always_inline zval *_get_zval_ptr_r_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_r_deref(int op_type, znode_op node, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
                if (op_type == IS_TMP_VAR) {
-                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+                       return _get_zval_ptr_tmp(node.var, should_free EXECUTE_DATA_CC);
                } else {
                        ZEND_ASSERT(op_type == IS_VAR);
-                       return _get_zval_ptr_var_deref(node.var, execute_data, should_free);
+                       return _get_zval_ptr_var_deref(node.var, should_free EXECUTE_DATA_CC);
                }
        } else {
                *should_free = NULL;
                if (op_type == IS_CONST) {
                        return EX_CONSTANT(node);
                } else if (op_type == IS_CV) {
-                       return _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, node.var);
+                       return _get_zval_ptr_cv_deref_BP_VAR_R(node.var EXECUTE_DATA_CC);
                } else {
                        return NULL;
                }
        }
 }
 
-static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
                if (op_type == IS_TMP_VAR) {
-                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+                       return _get_zval_ptr_tmp(node.var, should_free EXECUTE_DATA_CC);
                } else {
                        ZEND_ASSERT(op_type == IS_VAR);
-                       return _get_zval_ptr_var(node.var, execute_data, should_free);
+                       return _get_zval_ptr_var(node.var, should_free EXECUTE_DATA_CC);
                }
        } else {
                *should_free = NULL;
                if (op_type == IS_CONST) {
                        return EX_CONSTANT(node);
                } else if (op_type == IS_CV) {
-                       return _get_zval_ptr_cv_undef(execute_data, node.var);
+                       return _get_zval_ptr_cv_undef(node.var EXECUTE_DATA_CC);
                } else {
                        return NULL;
                }
        }
 }
 
-static zend_always_inline zval *_get_zval_ptr_ptr_var(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
+static zend_always_inline zval *_get_zval_ptr_ptr_var(uint32_t var, zend_free_op *should_free EXECUTE_DATA_DC)
 {
        zval *ret = EX_VAR(var);
 
@@ -518,47 +553,47 @@ static zend_always_inline zval *_get_zval_ptr_ptr_var(uint32_t var, const zend_e
        return ret;
 }
 
-static inline zval *_get_zval_ptr_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static inline zval *_get_zval_ptr_ptr(int op_type, znode_op node, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type == IS_CV) {
                *should_free = NULL;
-               return _get_zval_ptr_cv(execute_data, node.var, type);
+               return _get_zval_ptr_cv(node.var, type EXECUTE_DATA_CC);
        } else /* if (op_type == IS_VAR) */ {
                ZEND_ASSERT(op_type == IS_VAR);
-               return _get_zval_ptr_ptr_var(node.var, execute_data, should_free);
+               return _get_zval_ptr_ptr_var(node.var, should_free EXECUTE_DATA_CC);
        }
 }
 
-static zend_always_inline zval *_get_obj_zval_ptr_unused(zend_execute_data *execute_data)
+static zend_always_inline zval *_get_obj_zval_ptr_unused(EXECUTE_DATA_D)
 {      
        return &EX(This);
 }
 
-static inline zval *_get_obj_zval_ptr(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static inline zval *_get_obj_zval_ptr(int op_type, znode_op op, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type == IS_UNUSED) {
                *should_free = NULL;
                return &EX(This);
        }
-       return get_zval_ptr(op_type, op, execute_data, should_free, type);
+       return get_zval_ptr(op_type, op, should_free, type);
 }
 
-static inline zval *_get_obj_zval_ptr_undef(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static inline zval *_get_obj_zval_ptr_undef(int op_type, znode_op op, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type == IS_UNUSED) {
                *should_free = NULL;
                return &EX(This);
        }
-       return get_zval_ptr_undef(op_type, op, execute_data, should_free, type);
+       return get_zval_ptr_undef(op_type, op, should_free, type);
 }
 
-static inline zval *_get_obj_zval_ptr_ptr(int op_type, znode_op node, zend_execute_data *execute_data, zend_free_op *should_free, int type)
+static inline zval *_get_obj_zval_ptr_ptr(int op_type, znode_op node, zend_free_op *should_free, int type EXECUTE_DATA_DC)
 {
        if (op_type == IS_UNUSED) {
                *should_free = NULL;
                return &EX(This);
        }
-       return get_zval_ptr_ptr(op_type, node, execute_data, should_free, type);
+       return get_zval_ptr_ptr(op_type, node, should_free, type);
 }
 
 static inline void zend_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr)
@@ -1006,7 +1041,7 @@ static zend_never_inline void zend_assign_to_object_dim(zval *object, zval *dim,
        Z_OBJ_HT_P(object)->write_dimension(object, dim, value);
 }
 
-static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *property, zval *value, zval *retval, binary_op_type binary_op)
+static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *property, zval *value, zval *retval, binary_op_type binary_op EXECUTE_DATA_DC)
 {
        zval *z;
        zval rv, res;
@@ -1040,7 +1075,7 @@ static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *
        }
 }
 
-static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type)
+static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type EXECUTE_DATA_DC)
 {
        zend_long offset;
 
@@ -1056,7 +1091,7 @@ try_again:
                                }
                                break;
                        case IS_UNDEF:
-                               zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                               zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                        case IS_DOUBLE:
                        case IS_NULL:
                        case IS_FALSE:
@@ -1079,10 +1114,10 @@ try_again:
        return offset;
 }
 
-static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void)
+static zend_never_inline ZEND_COLD void zend_wrong_string_offset(EXECUTE_DATA_D)
 {
        const char *msg = NULL;
-       const zend_op *opline = EG(current_execute_data)->opline;
+       const zend_op *opline = EX(opline);
        const zend_op *end;
        uint32_t var;
 
@@ -1198,14 +1233,14 @@ static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void)
        zend_throw_error(NULL, msg);
 }
 
-static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result)
+static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result EXECUTE_DATA_DC)
 {
        zend_string *old_str;
        zend_uchar c;
        size_t string_len;
        zend_long offset;
 
-       offset = zend_check_string_offset(dim, BP_VAR_W);
+       offset = zend_check_string_offset(dim, BP_VAR_W EXECUTE_DATA_CC);
        if (offset < -(zend_long)Z_STRLEN_P(str)) {
                /* Error on negative offset */
                zend_error(E_WARNING, "Illegal string offset:  " ZEND_LONG_FMT, offset);
@@ -1428,7 +1463,7 @@ static void zend_extension_fcall_end_handler(const zend_extension *extension, ze
 }
 
 
-static zend_always_inline HashTable *zend_get_target_symbol_table(zend_execute_data *execute_data, int fetch_type)
+static zend_always_inline HashTable *zend_get_target_symbol_table(int fetch_type EXECUTE_DATA_DC)
 {
        HashTable *ht;
 
@@ -1445,7 +1480,7 @@ static zend_always_inline HashTable *zend_get_target_symbol_table(zend_execute_d
        return ht;
 }
 
-static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type)
+static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type EXECUTE_DATA_DC)
 {
        zval *retval;
        zend_string *offset_key;
@@ -1526,7 +1561,7 @@ str_index:
        } else {
                switch (Z_TYPE_P(dim)) {
                        case IS_UNDEF:
-                               zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                               zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                                /* break missing intentionally */                               
                        case IS_NULL:
                                offset_key = ZSTR_EMPTY_ALLOC();
@@ -1556,27 +1591,27 @@ str_index:
        return retval;
 }
 
-static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W(HashTable *ht, const zval *dim)
+static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W(HashTable *ht, const zval *dim EXECUTE_DATA_DC)
 {
-       return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_W);
+       return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_W EXECUTE_DATA_CC);
 }
 
-static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W_CONST(HashTable *ht, const zval *dim)
+static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W_CONST(HashTable *ht, const zval *dim EXECUTE_DATA_DC)
 {
-       return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_W);
+       return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_W EXECUTE_DATA_CC);
 }
 
-static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW(HashTable *ht, const zval *dim)
+static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW(HashTable *ht, const zval *dim EXECUTE_DATA_DC)
 {
-       return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_RW);
+       return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_RW EXECUTE_DATA_CC);
 }
 
-static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW_CONST(HashTable *ht, const zval *dim)
+static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_RW_CONST(HashTable *ht, const zval *dim EXECUTE_DATA_DC)
 {
-       return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_RW);
+       return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_RW EXECUTE_DATA_CC);
 }
 
-static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type)
+static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type EXECUTE_DATA_DC)
 {
     zval *retval;
 
@@ -1592,7 +1627,7 @@ fetch_from_array:
                                return;
                        }
                } else {
-                       retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
+                       retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type EXECUTE_DATA_CC);
                        if (UNEXPECTED(!retval)) {
                                ZVAL_ERROR(result);
                                return;
@@ -1610,13 +1645,13 @@ fetch_from_array:
                if (dim == NULL) {
                        zend_throw_error(NULL, "[] operator not supported for strings");
                } else {
-                       zend_check_string_offset(dim, type);
-                       zend_wrong_string_offset();
+                       zend_check_string_offset(dim, type EXECUTE_DATA_CC);
+                       zend_wrong_string_offset(EXECUTE_DATA_C);
                }
                ZVAL_ERROR(result);
        } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
                if (/*dim_type == IS_CV &&*/ dim && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                        dim = &EG(uninitialized_zval);
                }
                if (!Z_OBJ_HT_P(container)->read_dimension) {
@@ -1659,10 +1694,10 @@ fetch_from_array:
                }
        } else {
                if (type != BP_VAR_W && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op1.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
                }
                if (/*dim_type == IS_CV &&*/ dim && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                }
                if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
                        if (type != BP_VAR_UNSET) {
@@ -1687,29 +1722,29 @@ fetch_from_array:
        }
 }
 
-static zend_never_inline void zend_fetch_dimension_address_W(zval *result, zval *container_ptr, zval *dim, int dim_type)
+static zend_never_inline void zend_fetch_dimension_address_W(zval *result, zval *container_ptr, zval *dim, int dim_type EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_W);
+       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_W EXECUTE_DATA_CC);
 }
 
-static zend_never_inline void zend_fetch_dimension_address_RW(zval *result, zval *container_ptr, zval *dim, int dim_type)
+static zend_never_inline void zend_fetch_dimension_address_RW(zval *result, zval *container_ptr, zval *dim, int dim_type EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_RW);
+       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_RW EXECUTE_DATA_CC);
 }
 
-static zend_never_inline void zend_fetch_dimension_address_UNSET(zval *result, zval *container_ptr, zval *dim, int dim_type)
+static zend_never_inline void zend_fetch_dimension_address_UNSET(zval *result, zval *container_ptr, zval *dim, int dim_type EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_UNSET);
+       zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_UNSET EXECUTE_DATA_CC);
 }
 
-static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type, int support_strings, int slow)
+static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type, int support_strings, int slow EXECUTE_DATA_DC)
 {
        zval *retval;
 
        if (!slow) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 try_array:
-                       retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
+                       retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type EXECUTE_DATA_CC);
                        ZVAL_COPY(result, retval);
                        return;
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -1737,7 +1772,7 @@ try_string_offset:
                                        zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim));
                                        break;
                                case IS_UNDEF:
-                                       zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                                       zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                                case IS_DOUBLE:
                                case IS_NULL:
                                case IS_FALSE:
@@ -1778,7 +1813,7 @@ try_string_offset:
                }
        } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
                if (/*dim_type == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                        dim = &EG(uninitialized_zval);
                }
                if (!Z_OBJ_HT_P(container)->read_dimension) {
@@ -1798,41 +1833,41 @@ try_string_offset:
                }
        } else {
                if (type != BP_VAR_IS && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op1.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
                }
                if (/*dim_type == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) {
-                       zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data));
+                       zval_undefined_cv(EX(opline)->op2.var EXECUTE_DATA_CC);
                }
                ZVAL_NULL(result);
        }
 }
 
-static zend_never_inline void zend_fetch_dimension_address_read_R(zval *result, zval *container, zval *dim, int dim_type)
+static zend_never_inline void zend_fetch_dimension_address_read_R(zval *result, zval *container, zval *dim, int dim_type EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R, 1, 0);
+       zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R, 1, 0 EXECUTE_DATA_CC);
 }
 
-static zend_never_inline void zend_fetch_dimension_address_read_R_slow(zval *result, zval *container, zval *dim)
+static zend_never_inline void zend_fetch_dimension_address_read_R_slow(zval *result, zval *container, zval *dim EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address_read(result, container, dim, IS_CV, BP_VAR_R, 1, 1);
+       zend_fetch_dimension_address_read(result, container, dim, IS_CV, BP_VAR_R, 1, 1 EXECUTE_DATA_CC);
 }
 
-static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result, zval *container, zval *dim, int dim_type)
+static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result, zval *container, zval *dim, int dim_type EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS, 1, 0);
+       zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS, 1, 0 EXECUTE_DATA_CC);
 }
 
-static zend_never_inline void zend_fetch_dimension_address_read_LIST(zval *result, zval *container, zval *dim)
+static zend_never_inline void zend_fetch_dimension_address_read_LIST(zval *result, zval *container, zval *dim EXECUTE_DATA_DC)
 {
-       zend_fetch_dimension_address_read(result, container, dim, IS_TMP_VAR, BP_VAR_R, 0, 0);
+       zend_fetch_dimension_address_read(result, container, dim, IS_TMP_VAR, BP_VAR_R, 0, 0 EXECUTE_DATA_CC);
 }
 
 ZEND_API void zend_fetch_dimension_const(zval *result, zval *container, zval *dim, int type)
 {
        if (type == BP_VAR_IS) {
-               zend_fetch_dimension_address_read_IS(result, container, dim, IS_CONST);
+               zend_fetch_dimension_address_read_IS(result, container, dim, IS_CONST NO_EXECUTE_DATA_CC);
        } else {
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST NO_EXECUTE_DATA_CC);
        }
 }
 
@@ -1914,7 +1949,7 @@ use_read_property:
        }
 }
 
-static zend_always_inline zval* zend_fetch_static_property_address(zend_execute_data *execute_data, zval *varname, zend_uchar varname_type, znode_op op2, zend_uchar op2_type, int type)
+static zend_always_inline zval* zend_fetch_static_property_address(zval *varname, zend_uchar varname_type, znode_op op2, zend_uchar op2_type, int type EXECUTE_DATA_DC)
 {
        zval *retval;
        zend_string *name;
@@ -1927,7 +1962,7 @@ static zend_always_inline zval* zend_fetch_static_property_address(zend_execute_
                zend_string_addref(name);
        } else {
                if (varname_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                       zval_undefined_cv(EX(opline)->op1.var, execute_data);
+                       zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
                }
                name = zval_get_string(varname);
        }
@@ -2349,7 +2384,7 @@ static zend_always_inline void zend_vm_stack_extend_call_frame(zend_execute_data
 }
 /* }}} */
 
-static zend_always_inline zend_generator *zend_get_running_generator(zend_execute_data *execute_data) /* {{{ */
+static zend_always_inline zend_generator *zend_get_running_generator(EXECUTE_DATA_D) /* {{{ */
 {
        /* The generator object is stored in EX(return_value) */
        zend_generator *generator = (zend_generator *) EX(return_value);
@@ -2897,22 +2932,6 @@ ZEND_API int ZEND_FASTCALL zend_do_fcall_overloaded(zend_execute_data *call, zva
 }
 /* }}} */
 
-#ifdef HAVE_GCC_GLOBAL_REGS
-# if defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(i386)
-#  define ZEND_VM_FP_GLOBAL_REG "%esi"
-#  define ZEND_VM_IP_GLOBAL_REG "%edi"
-# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__x86_64__)
-#  define ZEND_VM_FP_GLOBAL_REG "%r14"
-#  define ZEND_VM_IP_GLOBAL_REG "%r15"
-# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__powerpc64__)
-#  define ZEND_VM_FP_GLOBAL_REG "r28"
-#  define ZEND_VM_IP_GLOBAL_REG "r29"
-# elif defined(__IBMC__) && ZEND_GCC_VERSION >= 4002 && defined(__powerpc64__)
-#  define ZEND_VM_FP_GLOBAL_REG "r28"
-#  define ZEND_VM_IP_GLOBAL_REG "r29"
-# endif
-#endif
-
 #define ZEND_VM_NEXT_OPCODE_EX(check_exception, skip) \
        CHECK_SYMBOL_TABLES() \
        if (check_exception) { \
@@ -3022,9 +3041,9 @@ ZEND_API int ZEND_FASTCALL zend_do_fcall_overloaded(zend_execute_data *call, zva
 #endif
 
 #define GET_OP1_UNDEF_CV(ptr, type) \
-       _get_zval_cv_lookup_ ## type(ptr, opline->op1.var, execute_data)
+       _get_zval_cv_lookup_ ## type(ptr, opline->op1.var EXECUTE_DATA_CC)
 #define GET_OP2_UNDEF_CV(ptr, type) \
-       _get_zval_cv_lookup_ ## type(ptr, opline->op2.var, execute_data)
+       _get_zval_cv_lookup_ ## type(ptr, opline->op2.var EXECUTE_DATA_CC)
 
 #define UNDEF_RESULT() do { \
                if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { \
@@ -3056,7 +3075,24 @@ ZEND_API user_opcode_handler_t zend_get_user_opcode_handler(zend_uchar opcode)
 
 ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
 {
-       return get_zval_ptr(op_type, *node, execute_data, should_free, type);
+       zval *ret;
+
+       switch (op_type) {
+               case IS_CONST:
+                       ret = EX_CONSTANT(*node);
+                       *should_free = NULL;
+               case IS_TMP_VAR:
+               case IS_VAR:
+                       ret = EX_VAR(node->var);
+                       *should_free = ret;
+               case IS_CV:
+                       ret = EX_VAR(node->var);
+                       *should_free = NULL;
+               default:
+                       ret = NULL;
+                       *should_free = ret;
+       }
+       return ret;
 }
 
 ZEND_API void ZEND_FASTCALL zend_check_internal_arg_type(zend_function *zf, uint32_t arg_num, zval *arg)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 7ba80a8bd62b343192994c8da8f4ce0f6ac66fdc..d0f371118573a9a2f07e54e4e99f9aa8650ae617 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -806,7 +806,7 @@ ZEND_VM_HELPER(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -871,9 +871,9 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array):
                        dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
 
                        if (OP2_TYPE == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                ZEND_VM_C_GOTO(assign_dim_op_ret_null);
@@ -882,7 +882,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array):
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -906,15 +906,15 @@ ZEND_VM_C_LABEL(assign_dim_op_convert_to_array):
                dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (OP2_TYPE == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -928,7 +928,7 @@ ZEND_VM_C_LABEL(assign_dim_op_ret_null):
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -1398,7 +1398,7 @@ ZEND_VM_HELPER(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED, int type)
                name = zval_get_string(varname);
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        retval = zend_hash_find(target_symbol_table, name);
        if (retval == NULL) {
                if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
@@ -1546,7 +1546,7 @@ ZEND_VM_HELPER(zend_fetch_static_prop_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR,
        SAVE_OPLINE();
        varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, OP1_TYPE, opline->op2, OP2_TYPE, type);
+       retval = zend_fetch_static_property_address(varname, OP1_TYPE, opline->op2, OP2_TYPE, type EXECUTE_DATA_CC);
        
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -1617,7 +1617,7 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        if (OP1_TYPE != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 ZEND_VM_C_LABEL(fetch_dim_r_array):
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, OP2_TYPE, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, OP2_TYPE, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -1630,11 +1630,11 @@ ZEND_VM_C_LABEL(fetch_dim_r_array):
                } else {
 ZEND_VM_C_LABEL(fetch_dim_r_slow):
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, OP2_TYPE);
+               zend_fetch_dimension_address_read_R(result, container, dim, OP2_TYPE EXECUTE_DATA_CC);
        }
        FREE_OP2();
        FREE_OP1();
@@ -1650,7 +1650,7 @@ ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV)
        SAVE_OPLINE();
        container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1668,7 +1668,7 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV)
        SAVE_OPLINE();
        container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1685,7 +1685,7 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
 
        SAVE_OPLINE();
        container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_IS);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
        FREE_OP2();
        FREE_OP1();
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -1708,7 +1708,7 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUS
                        HANDLE_EXCEPTION();
         }
                container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
                if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -1723,7 +1723,7 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUS
                        HANDLE_EXCEPTION();
                }
                container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
                FREE_OP2();
                FREE_OP1();
        }
@@ -1739,7 +1739,7 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV)
        SAVE_OPLINE();
        container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE EXECUTE_DATA_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -2005,7 +2005,7 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_LIST, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
 
        SAVE_OPLINE();
        container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R));
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R) EXECUTE_DATA_CC);
        FREE_OP2();
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -2189,9 +2189,9 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                } else {
                        dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
                        if (OP2_TYPE == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                ZEND_VM_C_GOTO(assign_dim_error);
@@ -2230,7 +2230,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                        } else {
                                dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
                                value = GET_OP_DATA_ZVAL_PTR_DEREF(BP_VAR_R);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                FREE_OP_DATA();
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -3931,7 +3931,7 @@ ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
        zval *retval;
        zend_free_op free_op1;
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        retval = GET_OP1_ZVAL_PTR(BP_VAR_R);
@@ -4600,7 +4600,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, NUM, ANY)
                zend_missing_arg_error(execute_data);
                HANDLE_EXCEPTION();
        } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
-               zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+               zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
 
                SAVE_OPLINE();
                if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) {
@@ -4620,7 +4620,7 @@ ZEND_VM_HOT_HANDLER(64, ZEND_RECV_INIT, NUM, CONST)
        ZEND_VM_REPEATABLE_OPCODE
 
        arg_num = opline->op1.num;
-       param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+       param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
        if (arg_num > EX_NUM_ARGS()) {
                ZVAL_COPY(param, EX_CONSTANT(opline->op2));
                if (Z_OPT_CONSTANT_P(param)) {
@@ -4655,7 +4655,7 @@ ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, NUM, ANY)
 
        SAVE_OPLINE();
 
-       params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+       params = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
 
        if (arg_num <= arg_count) {
                zval *param;
@@ -5365,7 +5365,7 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
                varname = &tmp;
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 
        if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -6021,7 +6021,7 @@ ZEND_VM_C_LABEL(fe_fetch_r_exit):
        }
 
        if (EXPECTED(OP2_TYPE == IS_CV)) {
-               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
+               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
                zend_assign_to_variable(variable_ptr, value, IS_CV);
        } else {
                zval *res = EX_VAR(opline->op2.var);
@@ -6221,7 +6221,7 @@ ZEND_VM_C_LABEL(fe_fetch_w_exit):
                ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
        }
        if (EXPECTED(OP2_TYPE == IS_CV)) {
-               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
+               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
                if (EXPECTED(variable_ptr != value)) {
                        zend_reference *ref;
 
@@ -6275,7 +6275,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|
                        varname = &tmp;
                }
 
-               target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
                value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
                if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -7078,7 +7078,7 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca
        /* Uncaught exception */
        cleanup_live_vars(execute_data, op_num, 0);
        if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
-               zend_generator *generator = zend_get_running_generator(execute_data);
+               zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
                zend_generator_close(generator, 1);
                ZEND_VM_RETURN();
        } else {
@@ -7162,7 +7162,7 @@ ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
                        ZEND_VM_CONTINUE();
                case ZEND_USER_OPCODE_RETURN:
                        if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
-                               zend_generator *generator = zend_get_running_generator(execute_data);
+                               zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
                                zend_generator_close(generator, 1);
                                ZEND_VM_RETURN();
                        } else {
@@ -7259,7 +7259,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -7396,7 +7396,7 @@ ZEND_VM_HANDLER(142, ZEND_YIELD_FROM, CONST|TMP|VAR|CV, ANY)
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        zval *val;
        zend_free_op free_op1;
@@ -8796,7 +8796,7 @@ ZEND_VM_C_LABEL(fetch_dim_r_index_array):
        } else {
 ZEND_VM_C_LABEL(fetch_dim_r_index_slow):
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
                FREE_OP1();
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index e9500a79b260a5a1980028f91e0ed9796a014e85..4773320344d4927e1b46a0f4f80cb884ef75d43a 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -338,18 +338,6 @@ static const void *zend_vm_get_opcode_handler_func(zend_uchar opcode, const zend
 #define HYBRID_DEFAULT    ZEND_NULL_LABEL
 #endif
 
-#ifdef ZEND_VM_FP_GLOBAL_REG
-#pragma GCC diagnostic ignored "-Wvolatile-register-var"
-register zend_execute_data* volatile execute_data __asm__(ZEND_VM_FP_GLOBAL_REG);
-#pragma GCC diagnostic warning "-Wvolatile-register-var"
-#endif
-
-#ifdef ZEND_VM_IP_GLOBAL_REG
-#pragma GCC diagnostic ignored "-Wvolatile-register-var"
-register const zend_op* volatile opline __asm__(ZEND_VM_IP_GLOBAL_REG);
-#pragma GCC diagnostic warning "-Wvolatile-register-var"
-#endif
-
 #ifdef ZEND_VM_FP_GLOBAL_REG
 # define ZEND_OPCODE_HANDLER_ARGS void
 # define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
@@ -1187,7 +1175,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_
        int arg_num;
 
        SAVE_OPLINE();
-       args = get_zval_ptr_undef(opline->op1_type, opline->op1, execute_data, &free_op1, BP_VAR_R);
+       args = get_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, BP_VAR_R);
        arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
 
 send_again:
@@ -1340,7 +1328,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O
        zval *args, *op2;
 
        SAVE_OPLINE();
-       args = get_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, BP_VAR_R);
+       args = get_zval_ptr(opline->op1_type, opline->op1, &free_op1, BP_VAR_R);
 
        if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
                if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
@@ -1370,7 +1358,7 @@ send_array:
                ht = Z_ARRVAL_P(args);
                if (opline->op2_type != IS_UNUSED) {
                        zend_free_op free_op2;
-                       zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, execute_data, &free_op2, BP_VAR_R);
+                       zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, &free_op2, BP_VAR_R);
                        uint32_t skip = opline->extended_value;
                        uint32_t count = zend_hash_num_elements(ht);
                        zend_long len = zval_get_long(op2);
@@ -1466,7 +1454,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_
                zend_missing_arg_error(execute_data);
                HANDLE_EXCEPTION();
        } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
-               zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+               zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
 
                SAVE_OPLINE();
                if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) {
@@ -1486,7 +1474,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEN
 
        SAVE_OPLINE();
 
-       params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+       params = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
 
        if (arg_num <= arg_count) {
                zval *param;
@@ -1745,7 +1733,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_hel
        /* Uncaught exception */
        cleanup_live_vars(execute_data, op_num, 0);
        if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
-               zend_generator *generator = zend_get_running_generator(execute_data);
+               zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
                zend_generator_close(generator, 1);
                ZEND_VM_RETURN();
        } else {
@@ -1829,7 +1817,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_
                        ZEND_VM_CONTINUE();
                case ZEND_USER_OPCODE_RETURN:
                        if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
-                               zend_generator *generator = zend_get_running_generator(execute_data);
+                               zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
                                zend_generator_close(generator, 1);
                                ZEND_VM_RETURN();
                        } else {
@@ -2301,7 +2289,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CON
        ZEND_VM_REPEATABLE_OPCODE
 
        arg_num = opline->op1.num;
-       param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
+       param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
        if (arg_num > EX_NUM_ARGS()) {
                ZVAL_COPY(param, EX_CONSTANT(opline->op2));
                if (Z_OPT_CONSTANT_P(param)) {
@@ -2446,7 +2434,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZE
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
 
-               zval *class_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               zval *class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
 try_class_name:
                if (IS_CV == IS_CONST) {
@@ -2486,7 +2474,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HAND
        zend_execute_data *call;
 
        SAVE_OPLINE();
-       function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
 try_function_name:
        if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
@@ -2544,7 +2532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMPVAR_HANDLE
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                zend_free_op free_op2;
-               zval *class_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
 try_class_name:
                if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
@@ -2585,7 +2573,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_
        zend_execute_data *call;
 
        SAVE_OPLINE();
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
 try_function_name:
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
@@ -3004,7 +2992,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HA
        zval *retval;
 
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        retval = EX_CONSTANT(opline->op1);
@@ -3962,7 +3950,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        zval *val;
 
@@ -4895,7 +4883,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        SAVE_OPLINE();
        varname = EX_CONSTANT(opline->op1);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CONST, opline->op2, IS_CONST, type);
+       retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_CONST, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -4964,7 +4952,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_H
        if (IS_CONST != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -4977,11 +4965,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST EXECUTE_DATA_CC);
        }
 
 
@@ -4996,7 +4984,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -5019,7 +5007,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -5034,7 +5022,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
                }
                container = EX_CONSTANT(opline->op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
 
        }
@@ -5225,7 +5213,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_CONST_HA
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2));
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -6283,7 +6271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -6548,7 +6536,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -6570,7 +6558,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HA
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -6588,7 +6576,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TM
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -6601,7 +6589,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -6682,7 +6670,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
        /* Set the new yielded key */
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
@@ -6742,7 +6730,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HA
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -6760,7 +6748,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VA
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -6779,7 +6767,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        SAVE_OPLINE();
        varname = EX_CONSTANT(opline->op1);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CONST, opline->op2, IS_VAR, type);
+       retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_VAR, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -6984,7 +6972,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -7065,7 +7053,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
        /* Set the new yielded key */
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
@@ -7140,7 +7128,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_
                name = zval_get_string(varname);
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        retval = zend_hash_find(target_symbol_table, name);
        if (retval == NULL) {
                if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
@@ -7288,7 +7276,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        SAVE_OPLINE();
        varname = EX_CONSTANT(opline->op1);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CONST, opline->op2, IS_UNUSED, type);
+       retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_UNUSED, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -7362,7 +7350,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -7377,7 +7365,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
                }
                container = EX_CONSTANT(opline->op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
 
        }
@@ -7747,7 +7735,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HA
                varname = &tmp;
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 
        if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -7851,7 +7839,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U
                        varname = &tmp;
                }
 
-               target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
                value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
                if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -7991,7 +7979,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -8292,7 +8280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -8335,7 +8323,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -8378,7 +8366,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -8425,7 +8413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8439,7 +8427,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -8478,7 +8466,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -8506,7 +8494,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -8535,7 +8523,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8549,7 +8537,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(Z
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -8615,7 +8603,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HAN
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
 
@@ -8633,7 +8621,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
 
@@ -8649,7 +8637,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -8717,7 +8705,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HAN
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -8785,7 +8773,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDL
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -8835,7 +8823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -8886,7 +8874,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLE
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8900,7 +8888,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZE
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -8927,7 +8915,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(Z
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -8954,7 +8942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(Z
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -8982,7 +8970,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8997,11 +8985,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HAND
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (IS_CONST != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -9014,11 +9002,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV EXECUTE_DATA_CC);
        }
 
 
@@ -9033,7 +9021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HAN
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -9056,7 +9044,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -9071,7 +9059,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
                }
                container = EX_CONSTANT(opline->op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
 
        }
@@ -9093,7 +9081,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HAND
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -9163,7 +9151,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HAN
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset  = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -9241,7 +9229,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -9262,7 +9250,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_CV_HANDL
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var));
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -9286,7 +9274,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HAND
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -9354,7 +9342,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -9505,7 +9493,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        } else if (IS_CV != IS_UNUSED) {
 
 
-               function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (IS_CV != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -9630,7 +9618,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
        SAVE_OPLINE();
-       function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       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;
@@ -9754,7 +9742,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEN
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -9857,7 +9845,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C
 
        if (IS_CV != IS_UNUSED) {
 
-               zval *offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               zval *offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -9944,7 +9932,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -10081,7 +10069,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CO
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -10114,7 +10102,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -10195,7 +10183,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
 
-               zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
@@ -10254,7 +10242,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zend_long offset;
 
        container = EX_CONSTANT(opline->op1);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -10281,7 +10269,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -10301,7 +10289,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVAR_HANDLER(
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -10344,7 +10332,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVAR_HANDLER(
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -10387,7 +10375,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMPVAR_HANDLER(
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -10434,7 +10422,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10448,7 +10436,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVAR_HANDLER(
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -10487,7 +10475,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVAR_HANDLER(Z
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -10515,7 +10503,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVAR_HANDLER(Z
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -10544,7 +10532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10558,7 +10546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDL
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -10622,7 +10610,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMPVAR_HAN
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -10690,7 +10678,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMPVAR
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -10758,7 +10746,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_H
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -10808,7 +10796,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -10859,7 +10847,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HA
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10873,7 +10861,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMPVAR_HANDLE
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -10900,7 +10888,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMPVAR_HANDL
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -10927,7 +10915,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMPVAR_HANDL
        zval *op1, *op2;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -10955,7 +10943,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMPVAR_HAN
 
        SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10970,11 +10958,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (IS_CONST != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -10987,11 +10975,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        }
        zval_ptr_dtor_nogc(free_op2);
 
@@ -11006,7 +10994,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -11029,7 +11017,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -11044,7 +11032,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
                        HANDLE_EXCEPTION();
                }
                container = EX_CONSTANT(opline->op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op2);
 
        }
@@ -11066,7 +11054,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -11137,7 +11125,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset  = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -11216,7 +11204,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
                zval_ptr_dtor_nogc(free_op2);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -11237,7 +11225,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_TMPVAR_H
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2));
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -11261,7 +11249,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -11329,7 +11317,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TM
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -11481,7 +11469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C
        } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
 
-               function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -11606,7 +11594,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
        uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
 
        SAVE_OPLINE();
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       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;
@@ -11676,7 +11664,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER
        zval *op1, *op2, *result;
 
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -11779,7 +11767,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T
 
        if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -11866,7 +11854,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON
 
        SAVE_OPLINE();
        container = EX_CONSTANT(opline->op1);
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -12003,7 +11991,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CO
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CONST == IS_CONST ||
            (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -12041,7 +12029,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zend_long offset;
 
        container = EX_CONSTANT(opline->op1);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -12068,7 +12056,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -12534,7 +12522,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA
        zval *return_value;
        zend_free_op free_op1;
 
-       retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       retval_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        return_value = EX(return_value);
        if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
                SAVE_OPLINE();
@@ -12606,7 +12594,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
-                       retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       retval_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                        if (!EX(return_value)) {
                                zval_ptr_dtor_nogc(free_op1);
                        } else {
@@ -12655,10 +12643,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HAND
        zval *retval;
        zend_free_op free_op1;
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
-       retval = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       retval = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        /* Copy return value into generator->retval */
        if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
@@ -12701,7 +12689,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OP
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        do {
                if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
@@ -12754,7 +12742,7 @@ send_val_by_ref:
                ZVAL_UNDEF(arg);
                HANDLE_EXCEPTION();
        }
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        ZVAL_COPY_VALUE(arg, value);
        if (IS_TMP_VAR == IS_CONST) {
@@ -12785,7 +12773,7 @@ send_val_by_ref:
                ZVAL_UNDEF(arg);
                HANDLE_EXCEPTION();
        }
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        ZVAL_COPY_VALUE(arg, value);
        if (IS_TMP_VAR == IS_CONST) {
@@ -12803,7 +12791,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEN
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       arg = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       arg = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        param = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
@@ -12828,7 +12816,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       expr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        switch (opline->extended_value) {
                case IS_NULL:
@@ -12910,7 +12898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZE
 
        SAVE_OPLINE();
 
-       array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       array_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
                result = EX_VAR(opline->result.var);
                ZVAL_COPY_VALUE(result, array_ptr);
@@ -13036,7 +13024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(Z
                        array_ptr = Z_REFVAL_P(array_ref);
                }
        } else {
-               array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        }
 
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
@@ -13213,7 +13201,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_
        int ret;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
                if (IS_TMP_VAR == IS_VAR) {
@@ -13263,7 +13251,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND
        zval *ref = NULL;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
                if (IS_TMP_VAR == IS_VAR) {
@@ -13303,7 +13291,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP
        zval *value;
        zval *result = EX_VAR(opline->result.var);
 
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(value, BP_VAR_R);
@@ -13340,13 +13328,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMP_HANDLER(ZE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        zval *val;
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
                zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
@@ -13449,7 +13437,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZE
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(value) == opline->extended_value)) {
                if (UNEXPECTED(Z_TYPE_P(value) == IS_RESOURCE)) {
                        const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(value));
@@ -13478,7 +13466,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HA
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -13496,7 +13484,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONS
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -13523,7 +13511,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CO
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -13537,8 +13525,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CO
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -13554,7 +13542,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HAN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_TMP_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -13752,7 +13740,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
@@ -13862,7 +13850,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -13891,7 +13879,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -13915,7 +13903,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
@@ -14003,7 +13991,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                result = zend_hash_exists(ht, Z_STR_P(op1));
        } else if (opline->extended_value) {
@@ -14042,8 +14030,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HAND
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -14060,8 +14048,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -14074,7 +14062,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -14103,7 +14091,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -14127,7 +14115,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
@@ -14155,7 +14143,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
        /* Set the new yielded key */
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
@@ -14214,8 +14202,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HAND
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -14232,8 +14220,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -14246,7 +14234,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -14275,7 +14263,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -14299,7 +14287,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
@@ -14327,7 +14315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
        /* Set the new yielded key */
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
@@ -14395,7 +14383,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UN
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -14409,8 +14397,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UN
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -14431,7 +14419,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN
                zend_free_op free_op1;
                zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
 
-               retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
@@ -14481,7 +14469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
@@ -14591,7 +14579,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -14620,7 +14608,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -14644,7 +14632,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
@@ -14731,7 +14719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMP_UNUSED_HANDLER(
        zend_long count;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        do {
                if (Z_TYPE_P(op1) == IS_ARRAY) {
                        count = zend_array_count(Z_ARRVAL_P(op1));
@@ -14788,7 +14776,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMP_UNUSED_HAND
                zval *op1;
 
                SAVE_OPLINE();
-               op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (Z_TYPE_P(op1) == IS_OBJECT) {
                        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
                } else {
@@ -14808,7 +14796,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDL
        zend_string *type;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        type = zend_zval_get_type(op1);
        if (EXPECTED(type)) {
                ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
@@ -14827,8 +14815,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDL
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -14845,8 +14833,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_H
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -14872,7 +14860,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -14886,8 +14874,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -14903,13 +14891,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLE
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_TMP_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_TMP_VAR == IS_CONST ||
            (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -14987,7 +14975,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -15010,10 +14998,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(Z
        /* op1 and result are the same */
        rope = (zend_string**)EX_VAR(opline->op1.var);
        if (IS_CV == IS_CONST) {
-               var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if (IS_CV == IS_CV) {
                                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
@@ -15045,10 +15033,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(Z
 
        rope = (zend_string**)EX_VAR(opline->op1.var);
        if (IS_CV == IS_CONST) {
-               var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if (IS_CV == IS_CV) {
                                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
@@ -15101,7 +15089,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
@@ -15131,7 +15119,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_
 
        if (IS_CV != IS_UNUSED) {
 
-               zval *offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               zval *offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -15211,7 +15199,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -15240,7 +15228,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -15264,7 +15252,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
@@ -15292,7 +15280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
 
-               zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
@@ -15350,14 +15338,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDL
        zval *closure, *var;
        zend_string *var_name;
 
-       closure = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       closure = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (opline->extended_value) {
                /* By-ref binding */
-               var = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(var);
                Z_ADDREF_P(var);
        } else {
-               var = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (UNEXPECTED(Z_ISUNDEF_P(var))) {
                        SAVE_OPLINE();
                        var = GET_OP2_UNDEF_CV(var, BP_VAR_R);
@@ -15391,7 +15379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TM
                        HANDLE_EXCEPTION();
         }
                container = NULL;
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -15405,8 +15393,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TM
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op2);
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -15422,13 +15410,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_TMPVAR_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_TMP_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_TMP_VAR == IS_CONST ||
            (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -15507,7 +15495,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TM
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
                zval_ptr_dtor_nogc(free_op2);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -15530,10 +15518,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDL
        /* op1 and result are the same */
        rope = (zend_string**)EX_VAR(opline->op1.var);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
@@ -15565,10 +15553,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDL
 
        rope = (zend_string**)EX_VAR(opline->op1.var);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                                rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
@@ -15621,7 +15609,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
@@ -15651,7 +15639,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP
 
        if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -15733,7 +15721,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
@@ -15773,7 +15761,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_H
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
@@ -15813,7 +15801,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
@@ -15853,7 +15841,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_H
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
@@ -15893,7 +15881,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
@@ -15926,7 +15914,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND
        zend_free_op free_op1;
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
@@ -15960,7 +15948,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA
        zval *return_value;
        zend_free_op free_op1;
 
-       retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       retval_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        return_value = EX(return_value);
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
                SAVE_OPLINE();
@@ -16032,7 +16020,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
-                       retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       retval_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                        if (!EX(return_value)) {
                                zval_ptr_dtor_nogc(free_op1);
                        } else {
@@ -16049,7 +16037,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER
                        break;
                }
 
-               retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_VAR) {
                        if (retval_ptr == &EG(uninitialized_zval) ||
@@ -16082,10 +16070,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HAND
        zval *retval;
        zend_free_op free_op1;
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
-       retval = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       retval = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        /* Copy return value into generator->retval */
        if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
@@ -16128,7 +16116,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OP
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
@@ -16167,7 +16155,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_
        zval *varptr, *arg;
        zend_free_op free_op1;
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -16206,7 +16194,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDL
        zend_free_op free_op1;
        zval *varptr, *arg;
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        ZVAL_COPY_VALUE(arg, varptr);
 
@@ -16231,7 +16219,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HA
                        ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
 
-               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -16244,7 +16232,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HA
                        ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
 
-               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -16271,7 +16259,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QU
                        ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
 
-               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -16284,7 +16272,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QU
                        ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
 
-               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -16306,7 +16294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND
        zval *varptr, *arg;
 
        SAVE_OPLINE();
-       varptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(varptr))) {
@@ -16344,7 +16332,7 @@ send_var_by_ref:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -16393,7 +16381,7 @@ send_var_by_ref:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -16433,7 +16421,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEN
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       arg = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       arg = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        param = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
@@ -16530,7 +16518,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       expr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        switch (opline->extended_value) {
                case IS_NULL:
@@ -16613,7 +16601,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZE
 
        SAVE_OPLINE();
 
-       array_ptr = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       array_ptr = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
                result = EX_VAR(opline->result.var);
                ZVAL_COPY_VALUE(result, array_ptr);
@@ -16736,12 +16724,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(Z
        SAVE_OPLINE();
 
        if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-               array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (Z_ISREF_P(array_ref)) {
                        array_ptr = Z_REFVAL_P(array_ref);
                }
        } else {
-               array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        }
 
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
@@ -17065,7 +17053,7 @@ fe_fetch_r_exit:
        }
 
        if (EXPECTED(opline->op2_type == IS_CV)) {
-               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
+               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
                zend_assign_to_variable(variable_ptr, value, IS_CV);
        } else {
                zval *res = EX_VAR(opline->op2.var);
@@ -17265,7 +17253,7 @@ fe_fetch_w_exit:
                ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
        }
        if (EXPECTED(opline->op2_type == IS_CV)) {
-               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op2.var);
+               zval *variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
                if (EXPECTED(variable_ptr != value)) {
                        zend_reference *ref;
 
@@ -17290,7 +17278,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_
        int ret;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
                if (IS_VAR == IS_VAR) {
@@ -17340,7 +17328,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND
        zval *ref = NULL;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
                if (IS_VAR == IS_VAR) {
@@ -17380,7 +17368,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR
        zval *value;
        zval *result = EX_VAR(opline->result.var);
 
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(value, BP_VAR_R);
@@ -17417,13 +17405,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_VAR_HANDLER(ZE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        zval *val;
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
                zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
@@ -17528,7 +17516,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_VAR_HANDLER(ZE
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(value) == opline->extended_value)) {
                if (UNEXPECTED(Z_TYPE_P(value) == IS_RESOURCE)) {
                        const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(value));
@@ -17555,7 +17543,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SP
        zval *varptr, *arg;
        zend_free_op free_op1;
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_VAR == IS_CV) {
@@ -17583,7 +17571,7 @@ send_var_by_ref_simple:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_VAR == IS_CV) {
@@ -17612,7 +17600,7 @@ send_var_by_ref_simple:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_VAR == IS_CV) {
@@ -17633,7 +17621,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HA
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -17651,7 +17639,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONS
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -17671,7 +17659,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -17680,7 +17668,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = EX_CONSTANT(opline->op2);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -17729,7 +17717,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -17745,9 +17733,9 @@ assign_dim_op_new_array:
                        dim = EX_CONSTANT(opline->op2);
 
                        if (IS_CONST == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -17756,7 +17744,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -17780,15 +17768,15 @@ assign_dim_op_convert_to_array:
                dim = EX_CONSTANT(opline->op2);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_CONST == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -17802,7 +17790,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -17820,7 +17808,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -18090,7 +18078,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18166,7 +18154,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18235,9 +18223,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18253,9 +18241,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18280,8 +18268,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CO
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -18295,8 +18283,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CO
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -18310,9 +18298,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18330,7 +18318,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HAN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18400,7 +18388,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HAN
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -18423,7 +18411,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18449,7 +18437,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CO
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18481,7 +18469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18505,7 +18493,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -18659,14 +18647,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -18813,14 +18801,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -18967,14 +18955,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -19125,7 +19113,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -19139,9 +19127,9 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -19179,7 +19167,7 @@ try_assign_dim_array:
                        } else {
                                dim = EX_CONSTANT(opline->op2);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -19217,7 +19205,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -19231,15 +19219,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -19253,7 +19241,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -19271,8 +19259,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -19310,7 +19298,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -19324,15 +19312,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -19346,7 +19334,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -19364,8 +19352,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -19403,7 +19391,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -19417,15 +19405,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -19439,7 +19427,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -19456,8 +19444,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -19493,7 +19481,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -19521,7 +19509,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -19789,12 +19777,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON
        SAVE_OPLINE();
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        } else {
-               expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
@@ -19910,7 +19898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDL
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        offset = EX_CONSTANT(opline->op2);
 
        do {
@@ -19999,7 +19987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDL
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -20031,7 +20019,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -20060,7 +20048,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -20068,7 +20056,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -20085,7 +20073,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
                } else {
-                       zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
@@ -20173,7 +20161,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                result = zend_hash_exists(ht, Z_STR_P(op1));
        } else if (opline->extended_value) {
@@ -20212,8 +20200,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HAND
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -20230,8 +20218,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -20248,8 +20236,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNU
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -20276,8 +20264,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USE
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -20300,7 +20288,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -20329,7 +20317,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -20337,7 +20325,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -20354,7 +20342,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
                } else {
-                       zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
@@ -20382,7 +20370,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
        /* Set the new yielded key */
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
@@ -20441,8 +20429,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HAND
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -20459,8 +20447,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -20477,8 +20465,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNU
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -20505,8 +20493,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USE
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -20533,8 +20521,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE
        zval *value_ptr;
 
        SAVE_OPLINE();
-       value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
@@ -20587,7 +20575,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -20616,7 +20604,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -20624,7 +20612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -20641,7 +20629,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
                } else {
-                       zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
@@ -20669,7 +20657,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
        /* Set the new yielded key */
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
@@ -20728,7 +20716,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -20744,9 +20732,9 @@ assign_dim_op_new_array:
                        dim = NULL;
 
                        if (IS_UNUSED == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -20755,7 +20743,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -20779,15 +20767,15 @@ assign_dim_op_convert_to_array:
                dim = NULL;
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_UNUSED == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -20801,7 +20789,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -20897,9 +20885,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -20915,9 +20903,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_H
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -20942,8 +20930,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UN
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -20957,8 +20945,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UN
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -20976,7 +20964,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -20990,9 +20978,9 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -21030,7 +21018,7 @@ try_assign_dim_array:
                        } else {
                                dim = NULL;
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -21068,7 +21056,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -21082,15 +21070,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -21104,7 +21092,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -21122,8 +21110,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -21161,7 +21149,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -21175,15 +21163,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -21197,7 +21185,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -21215,8 +21203,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -21254,7 +21242,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -21268,15 +21256,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -21290,7 +21278,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -21307,8 +21295,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -21504,7 +21492,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN
                zend_free_op free_op1;
                zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
 
-               retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
@@ -21549,12 +21537,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU
        SAVE_OPLINE();
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        } else {
-               expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
@@ -21679,7 +21667,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -21708,7 +21696,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -21716,7 +21704,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -21733,7 +21721,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
                } else {
-                       zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
@@ -21848,7 +21836,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_VAR_UNUSED_HANDLER(
        zend_long count;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        do {
                if (Z_TYPE_P(op1) == IS_ARRAY) {
                        count = zend_array_count(Z_ARRVAL_P(op1));
@@ -21905,7 +21893,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_VAR_UNUSED_HAND
                zval *op1;
 
                SAVE_OPLINE();
-               op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+               op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (Z_TYPE_P(op1) == IS_OBJECT) {
                        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
                } else {
@@ -21925,7 +21913,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDL
        zend_string *type;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        type = zend_zval_get_type(op1);
        if (EXPECTED(type)) {
                ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
@@ -21944,8 +21932,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDL
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -21962,8 +21950,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_H
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -21982,16 +21970,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -22040,7 +22028,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -22053,12 +22041,12 @@ assign_dim_op_new_array:
                                goto assign_dim_op_ret_null;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
                        if (IS_CV == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -22067,7 +22055,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -22088,18 +22076,18 @@ assign_dim_op_convert_to_array:
                        goto assign_dim_op_new_array;
                }
 
-               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_CV == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -22113,7 +22101,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -22130,8 +22118,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
        zval *value;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -22401,13 +22389,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -22477,13 +22465,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -22546,9 +22534,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLE
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -22564,9 +22552,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDL
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -22591,8 +22579,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -22606,8 +22594,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -22621,9 +22609,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -22641,13 +22629,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLE
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_CONST ||
            (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -22711,12 +22699,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLE
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -22734,12 +22722,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDL
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -22760,7 +22748,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -22772,7 +22760,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -22792,13 +22780,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HA
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
 
@@ -22816,13 +22804,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -22970,14 +22958,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -23124,14 +23112,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -23278,14 +23266,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -23436,7 +23424,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23448,11 +23436,11 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -23471,7 +23459,7 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                        value = EX_CONSTANT((opline+1)->op1);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
@@ -23488,9 +23476,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -23501,7 +23489,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -23528,7 +23516,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23540,17 +23528,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23563,8 +23551,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -23581,9 +23569,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -23594,7 +23582,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -23621,7 +23609,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23633,17 +23621,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23656,8 +23644,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -23674,9 +23662,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -23687,7 +23675,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -23714,7 +23702,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23726,17 +23714,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23749,8 +23737,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -23766,9 +23754,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -23779,7 +23767,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -23803,8 +23791,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUS
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -23831,8 +23819,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -23859,8 +23847,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
        zval *value_ptr;
 
        SAVE_OPLINE();
-       value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
@@ -23952,7 +23940,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        } else if (IS_CV != IS_UNUSED) {
 
 
-               function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (IS_CV != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -24072,12 +24060,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_
        SAVE_OPLINE();
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        } else {
-               expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
@@ -24107,7 +24095,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_
 
        if (IS_CV != IS_UNUSED) {
 
-               zval *offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               zval *offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -24193,8 +24181,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-       offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -24282,11 +24270,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -24314,7 +24302,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -24343,7 +24331,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -24351,7 +24339,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+                               zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -24368,7 +24356,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
                } else {
-                       zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+                       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
@@ -24396,7 +24384,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
 
-               zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
@@ -24457,16 +24445,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -24515,7 +24503,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -24528,12 +24516,12 @@ assign_dim_op_new_array:
                                goto assign_dim_op_ret_null;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -24542,7 +24530,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -24563,18 +24551,18 @@ assign_dim_op_convert_to_array:
                        goto assign_dim_op_new_array;
                }
 
-               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -24588,7 +24576,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -24606,8 +24594,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
        zval *value;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -24878,13 +24866,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -24955,13 +24943,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -25025,9 +25013,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -25043,9 +25031,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_H
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -25070,8 +25058,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TM
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -25085,8 +25073,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TM
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op2);
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -25100,9 +25088,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -25120,13 +25108,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_CONST ||
            (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -25191,12 +25179,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HA
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -25214,12 +25202,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_H
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -25240,7 +25228,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TM
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -25252,7 +25240,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TM
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
                zval_ptr_dtor_nogc(free_op2);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -25272,13 +25260,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVA
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
        zval_ptr_dtor_nogc(free_op2);
@@ -25296,13 +25284,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -25450,14 +25438,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -25604,14 +25592,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -25758,14 +25746,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -25916,7 +25904,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -25928,11 +25916,11 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -25951,7 +25939,7 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        value = EX_CONSTANT((opline+1)->op1);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
@@ -25968,9 +25956,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -25981,7 +25969,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -26008,7 +25996,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -26020,17 +26008,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -26043,8 +26031,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -26061,9 +26049,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -26074,7 +26062,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -26101,7 +26089,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -26113,17 +26101,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -26136,8 +26124,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -26154,9 +26142,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -26167,7 +26155,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -26194,7 +26182,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -26206,17 +26194,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -26229,8 +26217,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -26246,9 +26234,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -26259,7 +26247,7 @@ try_assign_dim_array:
                        if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -26319,7 +26307,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V
        } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
 
-               function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -26439,12 +26427,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP
        SAVE_OPLINE();
        if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        } else {
-               expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               expr_ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
@@ -26474,7 +26462,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP
 
        if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -26560,8 +26548,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HAND
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -26650,11 +26638,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HAND
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -26761,7 +26749,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND
        zend_object_clone_obj_t clone_call;
 
        SAVE_OPLINE();
-       obj = _get_obj_zval_ptr_unused(execute_data);
+       obj = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -26867,7 +26855,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -26876,7 +26864,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = EX_CONSTANT(opline->op2);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -27006,7 +26994,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27082,7 +27070,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27153,7 +27141,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27223,7 +27211,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_
 
        SAVE_OPLINE();
 
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -27246,7 +27234,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27270,7 +27258,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27342,7 +27330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_obj_zval_ptr_unused(execute_data);
+               container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
                if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27374,7 +27362,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CO
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27398,7 +27386,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -27552,14 +27540,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -27706,14 +27694,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -27860,14 +27848,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -28054,7 +28042,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C
 
        SAVE_OPLINE();
 
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -28460,7 +28448,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -28497,7 +28485,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -28536,7 +28524,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -28672,7 +28660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -28753,7 +28741,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
        /* Set the new yielded key */
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
@@ -28808,7 +28796,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -28889,7 +28877,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
        /* Set the new yielded key */
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
@@ -29149,7 +29137,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -29441,16 +29429,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -29580,13 +29568,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -29656,13 +29644,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -29727,13 +29715,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -29797,12 +29785,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HAN
 
        SAVE_OPLINE();
 
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
        if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -29820,12 +29808,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
 
        if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -29844,13 +29832,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset  = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -29916,7 +29904,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_obj_zval_ptr_unused(execute_data);
+               container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
                if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -29928,7 +29916,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
                if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -29948,13 +29936,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
 
@@ -29972,13 +29960,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -30126,14 +30114,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -30280,14 +30268,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -30434,14 +30422,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -30591,10 +30579,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDL
        /* Compiler allocates the necessary number of zval slots to keep the rope */
        rope = (zend_string**)EX_VAR(opline->result.var);
        if (IS_CV == IS_CONST) {
-               var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                rope[0] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               var = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if (IS_CV == IS_CV) {
                                rope[0] = zend_string_copy(Z_STR_P(var));
@@ -30628,13 +30616,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C
 
        SAVE_OPLINE();
 
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -30785,7 +30773,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        } else if (IS_CV != IS_UNUSED) {
 
 
-               function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                if (IS_CV != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -30904,11 +30892,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDL
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -30941,13 +30929,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -30980,7 +30968,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -31061,7 +31049,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
 
-               zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
@@ -31122,16 +31110,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -31261,13 +31249,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -31338,13 +31326,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -31410,13 +31398,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -31481,12 +31469,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR
 
        SAVE_OPLINE();
 
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -31504,12 +31492,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -31528,13 +31516,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset  = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -31601,7 +31589,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_obj_zval_ptr_unused(execute_data);
+               container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
                if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -31613,7 +31601,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
                zval_ptr_dtor_nogc(free_op2);
                if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -31633,13 +31621,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TM
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
        zval_ptr_dtor_nogc(free_op2);
@@ -31657,13 +31645,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -31811,14 +31799,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -31965,14 +31953,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -32119,14 +32107,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -32276,10 +32264,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_H
        /* Compiler allocates the necessary number of zval slots to keep the rope */
        rope = (zend_string**)EX_VAR(opline->result.var);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                rope[0] = zend_string_copy(Z_STR_P(var));
        } else {
-               var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               var = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
                        if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
                                rope[0] = zend_string_copy(Z_STR_P(var));
@@ -32313,13 +32301,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T
 
        SAVE_OPLINE();
 
-       object = _get_obj_zval_ptr_unused(execute_data);
+       object = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -32471,7 +32459,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U
        } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
 
-               function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                        if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
                                do {
@@ -32590,11 +32578,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_H
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -32628,13 +32616,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_obj_zval_ptr_unused(execute_data);
+       container = _get_obj_zval_ptr_unused(EXECUTE_DATA_C);
 
        if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_UNUSED == IS_CONST ||
            (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -32670,7 +32658,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OP
 
        zval *op1;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
                ZEND_VM_NEXT_OPCODE();
@@ -32678,7 +32666,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OP
 
        SAVE_OPLINE();
        bitwise_not_function(EX_VAR(opline->result.var),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var));
+               _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC));
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -32689,7 +32677,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_
        zval *val;
 
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_FALSE(EX_VAR(opline->result.var));
        } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
@@ -32714,7 +32702,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
@@ -32753,7 +32741,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HA
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
@@ -32792,7 +32780,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
@@ -32831,7 +32819,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HA
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
@@ -32870,7 +32858,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
@@ -32902,7 +32890,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_
 
        zval *var_ptr;
 
-       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
@@ -32935,7 +32923,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCO
        zval *z;
 
        SAVE_OPLINE();
-       z = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       z = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (Z_TYPE_P(z) == IS_STRING) {
                zend_string *str = Z_STR_P(z);
@@ -32963,7 +32951,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDL
 
        zval *val;
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZEND_VM_SET_NEXT_OPCODE(opline + 1);
@@ -32995,7 +32983,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HAND
 
        zval *val;
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
@@ -33026,7 +33014,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HAN
 
        zval *val;
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
                ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
@@ -33059,7 +33047,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_O
        zval *val;
        int ret;
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
@@ -33096,7 +33084,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_
        zval *val;
        int ret;
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
@@ -33133,7 +33121,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN
        zval *return_value;
        zend_free_op free_op1;
 
-       retval_ptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       retval_ptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        return_value = EX(return_value);
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
                SAVE_OPLINE();
@@ -33205,7 +33193,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
-                       retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                        if (!EX(return_value)) {
 
                        } else {
@@ -33222,7 +33210,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(
                        break;
                }
 
-               retval_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+               retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_VAR) {
                        if (retval_ptr == &EG(uninitialized_zval) ||
@@ -33254,10 +33242,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDL
        zval *retval;
 
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
-       retval = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        /* Copy return value into generator->retval */
        if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
@@ -33300,7 +33288,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPC
 
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        do {
                if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
@@ -33339,7 +33327,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_H
        zval *varptr, *arg;
 
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -33379,7 +33367,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_
        zval *varptr, *arg;
 
        SAVE_OPLINE();
-       varptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(varptr))) {
@@ -33416,7 +33404,7 @@ send_var_by_ref:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -33465,7 +33453,7 @@ send_var_by_ref:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(varptr, BP_VAR_R);
@@ -33505,7 +33493,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND
 
 
        SAVE_OPLINE();
-       arg = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        param = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
@@ -33527,7 +33515,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCO
        zval *val;
 
 
-       val = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
        } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
@@ -33556,7 +33544,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPC
        zend_object_clone_obj_t clone_call;
 
        SAVE_OPLINE();
-       obj = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       obj = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -33631,7 +33619,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        switch (opline->extended_value) {
                case IS_NULL:
@@ -33711,7 +33699,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
        zval *inc_filename;
 
        SAVE_OPLINE();
-       inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
 
        if (UNEXPECTED(EG(exception) != NULL)) {
@@ -33780,7 +33768,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEN
 
        SAVE_OPLINE();
 
-       array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
                result = EX_VAR(opline->result.var);
                ZVAL_COPY_VALUE(result, array_ptr);
@@ -33900,12 +33888,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZE
        SAVE_OPLINE();
 
        if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-               array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (Z_ISREF_P(array_ref)) {
                        array_ptr = Z_REFVAL_P(array_ref);
                }
        } else {
-               array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        }
 
        if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
@@ -34070,7 +34058,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCO
        SAVE_OPLINE();
        if (IS_CV != IS_UNUSED) {
 
-               zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               zval *ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                do {
                        if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -34101,7 +34089,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_O
        int ret;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
                if (IS_CV == IS_VAR) {
@@ -34150,7 +34138,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_
        zval *ref = NULL;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
                if (IS_CV == IS_VAR) {
@@ -34189,7 +34177,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_
        zval *value;
        zval *result = EX_VAR(opline->result.var);
 
-       value = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
                SAVE_OPLINE();
                GET_OP1_UNDEF_CV(value, BP_VAR_R);
@@ -34226,13 +34214,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEN
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        zval *val;
 
 
        SAVE_OPLINE();
-       val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       val = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
                zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
@@ -34332,7 +34320,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP
        zval *value;
 
 
-       value = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
 
@@ -34383,7 +34371,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEN
 
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(value) == opline->extended_value)) {
                if (UNEXPECTED(Z_TYPE_P(value) == IS_RESOURCE)) {
                        const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(value));
@@ -34410,7 +34398,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SP
        zval *varptr, *arg;
 
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_CV == IS_CV) {
@@ -34438,7 +34426,7 @@ send_var_by_ref_simple:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_CV == IS_CV) {
@@ -34467,7 +34455,7 @@ send_var_by_ref_simple:
                ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       varptr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varptr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
 
        if (IS_CV == IS_CV) {
@@ -34486,7 +34474,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -34529,7 +34517,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -34572,7 +34560,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -34619,7 +34607,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
 
@@ -34633,7 +34621,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -34672,7 +34660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
@@ -34700,7 +34688,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
@@ -34729,7 +34717,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        pow_function(EX_VAR(opline->result.var), op1, op2);
 
@@ -34743,7 +34731,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(Z
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
 
        if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
@@ -34809,7 +34797,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HAN
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_identical_function(op1, op2);
 
@@ -34827,7 +34815,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        result = fast_is_not_identical_function(op1, op2);
 
@@ -34843,7 +34831,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -34911,7 +34899,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -34979,7 +34967,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDL
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -35029,7 +35017,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CO
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -35080,7 +35068,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLE
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        compare_function(EX_VAR(opline->result.var), op1, op2);
 
@@ -35094,7 +35082,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZE
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -35121,7 +35109,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(Z
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -35148,7 +35136,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(Z
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -35176,7 +35164,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
 
@@ -35194,7 +35182,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -35203,7 +35191,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = EX_CONSTANT(opline->op2);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -35252,7 +35240,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -35268,9 +35256,9 @@ assign_dim_op_new_array:
                        dim = EX_CONSTANT(opline->op2);
 
                        if (IS_CONST == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -35279,7 +35267,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -35303,15 +35291,15 @@ assign_dim_op_convert_to_array:
                dim = EX_CONSTANT(opline->op2);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_CONST == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -35325,7 +35313,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -35343,7 +35331,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -35613,7 +35601,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -35689,7 +35677,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -35759,9 +35747,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CV, opline->op2, IS_CONST, type);
+       retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_CONST, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -35825,12 +35813,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HAND
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        dim = EX_CONSTANT(opline->op2);
        if (IS_CV != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -35843,11 +35831,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST EXECUTE_DATA_CC);
        }
 
 
@@ -35861,9 +35849,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HAND
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35879,9 +35867,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35897,8 +35885,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -35920,8 +35908,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CON
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -35935,8 +35923,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CON
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+               container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
 
        }
@@ -35950,9 +35938,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35970,7 +35958,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HAND
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36040,7 +36028,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HAND
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -36063,7 +36051,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36087,7 +36075,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HAN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36159,7 +36147,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CON
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36191,7 +36179,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36215,8 +36203,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_CONST_HANDL
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2));
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -36228,7 +36216,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -36382,14 +36370,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -36536,14 +36524,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -36690,14 +36678,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
        property_name = EX_CONSTANT(opline->op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -36848,7 +36836,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -36862,9 +36850,9 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -36902,7 +36890,7 @@ try_assign_dim_array:
                        } else {
                                dim = EX_CONSTANT(opline->op2);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -36940,7 +36928,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -36954,15 +36942,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -36976,7 +36964,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -36994,8 +36982,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -37033,7 +37021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -37047,15 +37035,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -37069,7 +37057,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -37087,8 +37075,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -37126,7 +37114,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -37140,15 +37128,15 @@ try_assign_dim_array:
                } else {
                        dim = EX_CONSTANT(opline->op2);
                        if (IS_CONST == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -37162,7 +37150,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = EX_CONSTANT(opline->op2);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -37179,8 +37167,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = EX_CONSTANT(opline->op2);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -37216,7 +37204,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UN
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -37244,7 +37232,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_US
 
        SAVE_OPLINE();
        value = EX_CONSTANT(opline->op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -37271,7 +37259,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HAND
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -37344,7 +37332,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -37463,7 +37451,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEN
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -37532,12 +37520,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS
        SAVE_OPLINE();
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
@@ -37652,7 +37640,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CV_CONS
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -37709,7 +37697,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLE
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
        offset = EX_CONSTANT(opline->op2);
 
        do {
@@ -37798,7 +37786,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLE
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
@@ -37836,7 +37824,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -37924,7 +37912,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        offset = EX_CONSTANT(opline->op2);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -38056,7 +38044,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -38099,7 +38087,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDL
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       expr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -38144,7 +38132,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -38173,7 +38161,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                               value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -38181,7 +38169,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -38197,7 +38185,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
@@ -38339,7 +38327,7 @@ check_indirect:
                GC_REFCOUNT(ref)++;
        }
 
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
                zend_refcounted *ref = Z_COUNTED_P(variable_ptr);
@@ -38373,7 +38361,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_CONST_HAND
        zval *value;
        zval *variable_ptr;
 
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
        zval_ptr_dtor(variable_ptr);
 
        ht = EX(func)->op_array.static_variables;
@@ -38422,7 +38410,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CV_CONST_HAND
        zval *op, *jump_zv;
        HashTable *jumptable;
 
-       op = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        jumptable = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
 
        if (Z_TYPE_P(op) != IS_LONG) {
@@ -38451,7 +38439,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CV_CONST_HA
        zval *op, *jump_zv;
        HashTable *jumptable;
 
-       op = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        jumptable = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
 
        if (Z_TYPE_P(op) != IS_STRING) {
@@ -38482,7 +38470,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                result = zend_hash_exists(ht, Z_STR_P(op1));
        } else if (opline->extended_value) {
@@ -38520,7 +38508,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        dim = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
@@ -38548,7 +38536,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -38569,8 +38557,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDL
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -38587,8 +38575,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_H
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -38605,8 +38593,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUS
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -38633,8 +38621,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -38657,7 +38645,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -38686,7 +38674,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                               value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -38694,7 +38682,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -38710,7 +38698,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
@@ -38738,7 +38726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
        /* Set the new yielded key */
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
@@ -38797,8 +38785,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDL
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -38815,8 +38803,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_H
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -38833,9 +38821,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CV, opline->op2, IS_VAR, type);
+       retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_VAR, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -38900,8 +38888,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUS
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -38928,8 +38916,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                zval_ptr_dtor_nogc(free_op2);
@@ -38956,8 +38944,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
        zval *value_ptr;
 
        SAVE_OPLINE();
-       value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
@@ -39014,7 +39002,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR_
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -39071,7 +39059,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -39157,7 +39145,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       expr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -39202,7 +39190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -39231,7 +39219,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                               value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -39239,7 +39227,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -39255,7 +39243,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
@@ -39283,7 +39271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
        /* Set the new yielded key */
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *key = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
@@ -39342,7 +39330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -39358,9 +39346,9 @@ assign_dim_op_new_array:
                        dim = NULL;
 
                        if (IS_UNUSED == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -39369,7 +39357,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -39393,15 +39381,15 @@ assign_dim_op_convert_to_array:
                dim = NULL;
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_UNUSED == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -39415,7 +39403,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -39514,7 +39502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_
        HashTable *target_symbol_table;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST) {
                name = Z_STR_P(varname);
@@ -39528,7 +39516,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_
                name = zval_get_string(varname);
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        retval = zend_hash_find(target_symbol_table, name);
        if (retval == NULL) {
                if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
@@ -39674,9 +39662,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, IS_CV, opline->op2, IS_UNUSED, type);
+       retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_UNUSED, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -39740,9 +39728,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -39758,9 +39746,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -39785,8 +39773,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNU
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -39800,8 +39788,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNU
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED);
+               container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED EXECUTE_DATA_CC);
 
 
        }
@@ -39819,7 +39807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -39833,9 +39821,9 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -39873,7 +39861,7 @@ try_assign_dim_array:
                        } else {
                                dim = NULL;
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -39911,7 +39899,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -39925,15 +39913,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -39947,7 +39935,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -39965,8 +39953,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -40004,7 +39992,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40018,15 +40006,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40040,7 +40028,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -40058,8 +40046,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -40097,7 +40085,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40111,15 +40099,15 @@ try_assign_dim_array:
                } else {
                        dim = NULL;
                        if (IS_UNUSED == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40133,7 +40121,7 @@ try_assign_dim_array:
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
                        dim = NULL;
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -40150,8 +40138,8 @@ try_assign_dim_array:
                                HANDLE_EXCEPTION();
                        } else {
                                dim = NULL;
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -40192,7 +40180,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU
 
                zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
 
-               retval_ref = retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               retval_ref = retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
@@ -40237,12 +40225,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS
        SAVE_OPLINE();
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
@@ -40375,7 +40363,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDL
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
 
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -40386,7 +40374,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDL
                varname = &tmp;
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 
        if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -40405,7 +40393,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUS
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -40483,14 +40471,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUS
                HashTable *target_symbol_table;
 
                SAVE_OPLINE();
-               varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+               varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
                ZVAL_UNDEF(&tmp);
                if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                        ZVAL_STR(&tmp, zval_get_string(varname));
                        varname = &tmp;
                }
 
-               target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
                value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
                if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -40520,7 +40508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -40606,7 +40594,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HAND
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       expr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -40651,7 +40639,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -40680,7 +40668,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                               value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -40688,7 +40676,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -40704,7 +40692,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
@@ -40832,7 +40820,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(Z
        zend_long count;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        do {
                if (Z_TYPE_P(op1) == IS_ARRAY) {
                        count = zend_array_count(Z_ARRVAL_P(op1));
@@ -40889,7 +40877,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDL
                zval *op1;
 
                SAVE_OPLINE();
-               op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+               op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (Z_TYPE_P(op1) == IS_OBJECT) {
                        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
                } else {
@@ -40909,7 +40897,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLE
        zend_string *type;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
        type = zend_zval_get_type(op1);
        if (EXPECTED(type)) {
                ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
@@ -40926,8 +40914,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OP
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -40969,8 +40957,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OP
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -41012,8 +41000,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OP
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -41059,8 +41047,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OP
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -41073,8 +41061,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OP
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -41112,8 +41100,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPC
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -41140,8 +41128,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPC
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -41169,8 +41157,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OP
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -41183,8 +41171,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -41249,8 +41237,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLE
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_identical_function(op1, op2);
 
 
@@ -41267,8 +41255,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HA
        int result;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = fast_is_not_identical_function(op1, op2);
 
 
@@ -41283,8 +41271,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -41351,8 +41339,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -41419,8 +41407,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -41469,8 +41457,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -41520,8 +41508,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(Z
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -41534,8 +41522,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -41561,8 +41549,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -41588,8 +41576,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND
 
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -41616,8 +41604,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZE
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -41634,16 +41622,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -41692,7 +41680,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -41705,12 +41693,12 @@ assign_dim_op_new_array:
                                goto assign_dim_op_ret_null;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
                        if (IS_CV == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -41719,7 +41707,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -41740,18 +41728,18 @@ assign_dim_op_convert_to_array:
                        goto assign_dim_op_new_array;
                }
 
-               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if (IS_CV == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -41765,7 +41753,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -41782,8 +41770,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
        zval *value;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -42053,13 +42041,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -42129,13 +42117,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -42198,12 +42186,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (IS_CV != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -42216,11 +42204,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV EXECUTE_DATA_CC);
        }
 
 
@@ -42234,9 +42222,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -42252,9 +42240,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLE
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -42270,8 +42258,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLE
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -42293,8 +42281,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -42308,8 +42296,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+               container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
 
        }
@@ -42323,9 +42311,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -42343,13 +42331,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -42413,12 +42401,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -42436,12 +42424,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLE
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -42460,13 +42448,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLE
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset  = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -42532,7 +42520,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -42544,7 +42532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
 
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -42564,13 +42552,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HAN
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
 
@@ -42588,8 +42576,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_CV_HANDLER(
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var));
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -42601,13 +42589,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -42755,14 +42743,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -42909,14 +42897,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -43063,14 +43051,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -43221,7 +43209,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -43233,11 +43221,11 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -43256,7 +43244,7 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                        value = EX_CONSTANT((opline+1)->op1);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
@@ -43273,9 +43261,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -43286,7 +43274,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -43313,7 +43301,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -43325,17 +43313,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -43348,8 +43336,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -43366,9 +43354,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -43379,7 +43367,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -43406,7 +43394,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -43418,17 +43406,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -43441,8 +43429,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -43459,9 +43447,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -43472,7 +43460,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -43499,7 +43487,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -43511,17 +43499,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                        if (IS_CV == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -43534,8 +43522,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -43551,9 +43539,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -43564,7 +43552,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+                       dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -43588,8 +43576,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSE
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -43616,8 +43604,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_
        zval *variable_ptr;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
 
@@ -43644,8 +43632,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
        zval *value_ptr;
 
        SAVE_OPLINE();
-       value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var);
-       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
+       variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
@@ -43700,7 +43688,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -43711,7 +43699,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -43773,13 +43761,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -43892,8 +43880,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_O
 
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -43961,12 +43949,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H
        SAVE_OPLINE();
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
@@ -43996,7 +43984,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H
 
        if (IS_CV != IS_UNUSED) {
 
-               zval *offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+               zval *offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -44082,8 +44070,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(Z
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
-       offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -44171,11 +44159,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(Z
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -44209,8 +44197,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -44341,13 +44329,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -44380,7 +44368,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
 {
        USE_OPLINE
 
-       zend_generator *generator = zend_get_running_generator(execute_data);
+       zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
 
        SAVE_OPLINE();
        if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
@@ -44409,7 +44397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
 
                                zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
-                               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                               value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
                                        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
@@ -44417,7 +44405,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
                                        }
                                }
                        } else {
-                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+                               zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
@@ -44433,7 +44421,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
 
                        }
                } else {
-                       zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+                       zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
@@ -44461,7 +44449,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
 
-               zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+               zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
@@ -44519,8 +44507,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -44547,7 +44535,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -44566,8 +44554,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMPVAR_HANDLER(ZEN
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -44609,8 +44597,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CV_TMPVAR_HANDLER(ZEN
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -44652,8 +44640,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMPVAR_HANDLER(ZEN
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -44699,8 +44687,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEN
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -44713,8 +44701,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMPVAR_HANDLER(ZEN
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -44752,8 +44740,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_TMPVAR_HANDLER(ZEND
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -44780,8 +44768,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_TMPVAR_HANDLER(ZEND
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -44809,8 +44797,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEN
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -44823,8 +44811,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -44887,8 +44875,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -44955,8 +44943,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -45023,8 +45011,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HAND
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -45073,8 +45061,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TM
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -45124,8 +45112,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDL
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -45138,8 +45126,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMPVAR_HANDLER(Z
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -45165,8 +45153,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMPVAR_HANDLER(
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -45192,8 +45180,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMPVAR_HANDLER(
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -45220,8 +45208,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLE
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -45238,16 +45226,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -45296,7 +45284,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
        zval *value, *container, *dim;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 assign_dim_op_array:
@@ -45309,12 +45297,12 @@ assign_dim_op_new_array:
                                goto assign_dim_op_ret_null;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        } else {
-                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim);
+                               var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
@@ -45323,7 +45311,7 @@ assign_dim_op_new_array:
                        SEPARATE_ZVAL_NOREF(var_ptr);
                }
 
-               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
                binary_op(var_ptr, var_ptr, value);
 
@@ -45344,18 +45332,18 @@ assign_dim_op_convert_to_array:
                        goto assign_dim_op_new_array;
                }
 
-               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
                if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+                       zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op EXECUTE_DATA_CC);
                } else {
                        if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
                                        zend_throw_error(NULL, "[] operator not supported for strings");
                                } else {
-                                       zend_check_string_offset(dim, BP_VAR_RW);
-                                       zend_wrong_string_offset();
+                                       zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
+                                       zend_wrong_string_offset(EXECUTE_DATA_C);
                                }
                                UNDEF_RESULT();
                        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -45369,7 +45357,7 @@ assign_dim_op_ret_null:
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        }
-                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
                }
        }
 
@@ -45387,8 +45375,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
        zval *value;
 
        SAVE_OPLINE();
-       value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       value = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -45659,13 +45647,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -45736,13 +45724,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *zptr;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -45806,12 +45794,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HAN
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (IS_CV != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -45824,11 +45812,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        }
        zval_ptr_dtor_nogc(free_op2);
 
@@ -45842,9 +45830,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -45860,9 +45848,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -45878,8 +45866,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -45901,8 +45889,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
         }
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -45916,8 +45904,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+               container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op2);
 
        }
@@ -45931,9 +45919,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -45951,13 +45939,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -46022,12 +46010,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HAN
 
        SAVE_OPLINE();
 
-       container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -46045,12 +46033,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -46069,13 +46057,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset  = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -46142,7 +46130,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP
                zval *property;
 
                SAVE_OPLINE();
-               container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+               container = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                        ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -46154,7 +46142,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
-               property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
                zval_ptr_dtor_nogc(free_op2);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
@@ -46174,13 +46162,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR
        zval *container, *property;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
        zval_ptr_dtor_nogc(free_op2);
@@ -46198,8 +46186,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_TMPVAR_HAND
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2));
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -46211,13 +46199,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        value = EX_CONSTANT((opline+1)->op1);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
@@ -46365,14 +46353,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -46519,14 +46507,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -46673,14 +46661,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        zval *object, *property_name, *value, tmp;
 
        SAVE_OPLINE();
-       object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-       value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+       property_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
@@ -46831,7 +46819,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46843,11 +46831,11 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
@@ -46866,7 +46854,7 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        value = EX_CONSTANT((opline+1)->op1);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
@@ -46883,9 +46871,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                                value = EX_CONSTANT((opline+1)->op1);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -46896,7 +46884,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -46923,7 +46911,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46935,17 +46923,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -46958,8 +46946,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -46976,9 +46964,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -46989,7 +46977,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -47016,7 +47004,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -47028,17 +47016,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data);
+               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -47051,8 +47039,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -47069,9 +47057,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -47082,7 +47070,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -47109,7 +47097,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
+       object_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -47121,17 +47109,17 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                } else {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        } else {
-                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim);
+                               variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
                        }
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
                }
-               value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var);
+               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
                value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -47144,8 +47132,8 @@ try_assign_dim_array:
                        }
                }
                if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                       value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                       value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
                        zend_assign_to_object_dim(object_ptr, dim, value);
 
@@ -47161,9 +47149,9 @@ try_assign_dim_array:
                                UNDEF_RESULT();
                                HANDLE_EXCEPTION();
                        } else {
-                               dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-                               value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var);
-                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+                               dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+                               value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                               zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL) EXECUTE_DATA_CC);
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
@@ -47174,7 +47162,7 @@ try_assign_dim_array:
                        if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                        }
-                       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+                       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 assign_dim_error:
 
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -47198,7 +47186,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HAN
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -47209,7 +47197,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HAN
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -47271,13 +47259,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       object = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -47391,8 +47379,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMPVAR_HANDLER(ZE
        zend_free_op free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -47460,12 +47448,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV
        SAVE_OPLINE();
        if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
            UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
                ZVAL_MAKE_REF(expr_ptr);
                Z_ADDREF_P(expr_ptr);
 
        } else {
-               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+               expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
@@ -47495,7 +47483,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV
 
        if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op2;
-               zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
                zend_string *str;
                zend_ulong hval;
 
@@ -47581,8 +47569,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDL
        zend_string *key;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(execute_data, opline->op1.var);
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_cv_undef_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -47671,11 +47659,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDL
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(opline->op1.var EXECUTE_DATA_CC);
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
@@ -47710,8 +47698,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -47842,13 +47830,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var);
+       container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (IS_CV == IS_CONST ||
            (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -47885,8 +47873,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -47913,7 +47901,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
 
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -47932,7 +47920,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVAR_HANDLER(ZEN
        zend_free_op free_op1;
        zval *op1;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
                ZEND_VM_NEXT_OPCODE();
@@ -47940,7 +47928,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVAR_HANDLER(ZEN
 
        SAVE_OPLINE();
        bitwise_not_function(EX_VAR(opline->result.var),
-               _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1));
+               _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC));
        zval_ptr_dtor_nogc(free_op1);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -47951,7 +47939,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(Z
        zval *val;
        zend_free_op free_op1;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_FALSE(EX_VAR(opline->result.var));
        } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
@@ -47977,7 +47965,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_
        zval *z;
 
        SAVE_OPLINE();
-       z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       z = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (Z_TYPE_P(z) == IS_STRING) {
                zend_string *str = Z_STR_P(z);
@@ -48006,7 +47994,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_H
        zend_free_op free_op1;
        zval *val;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZEND_VM_SET_NEXT_OPCODE(opline + 1);
@@ -48038,7 +48026,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_
        zend_free_op free_op1;
        zval *val;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
@@ -48069,7 +48057,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMPVAR
        zend_free_op free_op1;
        zval *val;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
                ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
@@ -48102,7 +48090,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZE
        zval *val;
        int ret;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
@@ -48139,7 +48127,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(Z
        zval *val;
        int ret;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
@@ -48198,7 +48186,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPV
        zval *value, *arg;
        zend_free_op free_op1;
 
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        ZVAL_COPY_VALUE(arg, value);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
@@ -48215,7 +48203,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_
        zval *val;
        zend_free_op free_op1;
 
-       val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (Z_TYPE_INFO_P(val) == IS_TRUE) {
                ZVAL_TRUE(EX_VAR(opline->result.var));
        } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
@@ -48244,7 +48232,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND
        zend_object_clone_obj_t clone_call;
 
        SAVE_OPLINE();
-       obj = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       obj = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -48320,7 +48308,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
        zval *inc_filename;
 
        SAVE_OPLINE();
-       inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       inc_filename = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
        zval_ptr_dtor_nogc(free_op1);
        if (UNEXPECTED(EG(exception) != NULL)) {
@@ -48387,7 +48375,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_TMPVAR_HANDLER(ZEND_
        SAVE_OPLINE();
        if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
                zend_free_op free_op1;
-               zval *ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               zval *ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                do {
                        if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -48415,7 +48403,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN
        zval *value;
        zend_free_op free_op1;
 
-       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
                zval_ptr_dtor_nogc(free_op1);
@@ -48464,7 +48452,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CONST_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -48507,7 +48495,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVAR_CONST_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -48550,7 +48538,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVAR_CONST_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -48597,7 +48585,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -48611,7 +48599,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_CONST_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -48650,7 +48638,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_CONST_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
@@ -48678,7 +48666,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_CONST_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
@@ -48707,7 +48695,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        pow_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -48721,7 +48709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDL
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
 
        if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
@@ -48785,7 +48773,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -48853,7 +48841,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -48921,7 +48909,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_H
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -48971,7 +48959,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -49022,7 +49010,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HA
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        compare_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -49036,7 +49024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_CONST_HANDLE
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -49063,7 +49051,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_CONST_HANDL
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -49090,7 +49078,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_CONST_HANDL
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
@@ -49118,7 +49106,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HAN
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -49134,9 +49122,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_CONST, type);
+       retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_CONST, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -49202,12 +49190,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        dim = EX_CONSTANT(opline->op2);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -49220,11 +49208,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CONST EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op1);
@@ -49238,8 +49226,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -49254,7 +49242,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -49322,8 +49310,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_CONST_H
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2));
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -49336,7 +49324,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -49409,7 +49397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -49529,7 +49517,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = EX_CONSTANT(opline->op2);
        do {
                int result;
@@ -49598,7 +49586,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -49655,7 +49643,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -49744,7 +49732,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        offset = EX_CONSTANT(opline->op2);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
@@ -49876,7 +49864,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -49919,7 +49907,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_H
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       expr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -49967,7 +49955,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVAR_CONST_
        zval *op, *jump_zv;
        HashTable *jumptable;
 
-       op = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        jumptable = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
 
        if (Z_TYPE_P(op) != IS_LONG) {
@@ -49996,7 +49984,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVAR_CONS
        zval *op, *jump_zv;
        HashTable *jumptable;
 
-       op = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        jumptable = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
 
        if (Z_TYPE_P(op) != IS_STRING) {
@@ -50025,7 +50013,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        dim = EX_CONSTANT(opline->op2);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
@@ -50053,7 +50041,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op1);
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -50074,9 +50062,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_VAR, type);
+       retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_VAR, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -50144,7 +50132,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -50201,7 +50189,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -50288,7 +50276,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HAN
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       expr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -50339,7 +50327,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_
        HashTable *target_symbol_table;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                name = Z_STR_P(varname);
@@ -50353,7 +50341,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_
                name = zval_get_string(varname);
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        retval = zend_hash_find(target_symbol_table, name);
        if (retval == NULL) {
                if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
@@ -50499,9 +50487,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_
        zval *retval;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       retval = zend_fetch_static_property_address(execute_data, varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_UNUSED, type);
+       retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_UNUSED, type EXECUTE_DATA_CC);
 
        if (UNEXPECTED(retval == NULL)) {
                if (EG(exception)) {
@@ -50587,7 +50575,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_H
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
 
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -50598,7 +50586,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_H
                varname = &tmp;
        }
 
-       target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
        zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -50617,7 +50605,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_
 
        SAVE_OPLINE();
 
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -50695,14 +50683,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_
                HashTable *target_symbol_table;
 
                SAVE_OPLINE();
-               varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
                ZVAL_UNDEF(&tmp);
                if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                        ZVAL_STR(&tmp, zval_get_string(varname));
                        varname = &tmp;
                }
 
-               target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK);
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
                value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
                if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
@@ -50733,7 +50721,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zend_class_entry *ce;
 
        SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        ZVAL_UNDEF(&tmp);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
                ZVAL_STR(&tmp, zval_get_string(varname));
@@ -50820,7 +50808,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_
        zend_bool result;
 
        SAVE_OPLINE();
-       expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       expr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
 try_instanceof:
        if (Z_TYPE_P(expr) == IS_OBJECT) {
@@ -50867,8 +50855,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CV_HANDLER(ZEN
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -50910,8 +50898,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVAR_CV_HANDLER(ZEN
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -50953,8 +50941,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVAR_CV_HANDLER(ZEN
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -51000,8 +50988,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEN
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51014,8 +51002,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_CV_HANDLER(ZEN
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -51053,8 +51041,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_CV_HANDLER(ZEND
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -51081,8 +51069,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_CV_HANDLER(ZEND
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -51110,8 +51098,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEN
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51124,8 +51112,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -51188,8 +51176,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CV_HANDLE
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -51256,8 +51244,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CV_HA
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -51324,8 +51312,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HAND
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -51374,8 +51362,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -51425,8 +51413,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDL
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51439,8 +51427,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_CV_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -51466,8 +51454,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_CV_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -51493,8 +51481,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_CV_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -51521,8 +51509,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CV_HANDLE
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51536,12 +51524,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HAN
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -51554,11 +51542,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV);
+               zend_fetch_dimension_address_read_R(result, container, dim, IS_CV EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op1);
@@ -51572,8 +51560,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var), IS_CV);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC), IS_CV EXECUTE_DATA_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -51588,13 +51576,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset  = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
            ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -51656,8 +51644,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_CV_HAND
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(execute_data, opline->op2.var));
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC) EXECUTE_DATA_CC);
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -51670,7 +51658,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HAN
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -51681,7 +51669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HAN
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (IS_CV == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -51743,13 +51731,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -51863,8 +51851,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE
        zend_free_op free_op1;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -51933,8 +51921,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       offset = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -52065,13 +52053,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
            ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -52107,8 +52095,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -52135,7 +52123,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op1);
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }
@@ -52154,8 +52142,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_TMPVAR_HANDLER
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -52197,8 +52185,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVAR_TMPVAR_HANDLER
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -52240,8 +52228,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVAR_TMPVAR_HANDLER
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        zend_long overflow;
@@ -52287,8 +52275,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        fast_div_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -52301,8 +52289,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_TMPVAR_HANDLER
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        result = EX_VAR(opline->result.var);
@@ -52340,8 +52328,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_TMPVAR_HANDLER(
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -52368,8 +52356,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_TMPVAR_HANDLER(
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
                        && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
@@ -52397,8 +52385,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        pow_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -52411,8 +52399,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HAND
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
            ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
@@ -52475,8 +52463,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -52543,8 +52531,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -52611,8 +52599,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -52661,8 +52649,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -52712,8 +52700,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_H
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        compare_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -52726,8 +52714,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_TMPVAR_HANDL
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
@@ -52753,8 +52741,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_TMPVAR_HAND
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
@@ -52780,8 +52768,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR_HAND
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
                        && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
@@ -52808,8 +52796,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HA
        zval *op1, *op2;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -52823,12 +52811,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR
        zval *container, *dim, *value, *result;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
                if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_array:
-                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R);
+                       value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
                        result = EX_VAR(opline->result.var);
                        ZVAL_COPY_UNREF(result, value);
                } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
@@ -52841,11 +52829,11 @@ fetch_dim_r_array:
                } else {
 fetch_dim_r_slow:
                        result = EX_VAR(opline->result.var);
-                       zend_fetch_dimension_address_read_R_slow(result, container, dim);
+                       zend_fetch_dimension_address_read_R_slow(result, container, dim EXECUTE_DATA_CC);
                }
        } else {
                result = EX_VAR(opline->result.var);
-               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR));
+               zend_fetch_dimension_address_read_R(result, container, dim, (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        }
        zval_ptr_dtor_nogc(free_op2);
        zval_ptr_dtor_nogc(free_op1);
@@ -52859,8 +52847,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        zval_ptr_dtor_nogc(free_op1);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -52875,13 +52863,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVA
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset  = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
            ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -52944,8 +52932,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_TMPVAR_
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2));
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zend_fetch_dimension_address_read_LIST(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC) EXECUTE_DATA_CC);
        zval_ptr_dtor_nogc(free_op2);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -52958,7 +52946,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR
        zend_string *op1_str, *op2_str, *str;
 
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op1_str = Z_STR_P(op1);
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
@@ -52969,7 +52957,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR
                }
                op1_str = _zval_get_string_func(op1);
        }
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
                op2_str = Z_STR_P(op2);
        } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
@@ -53031,13 +53019,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T
 
        SAVE_OPLINE();
 
-       object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       object = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
            UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
@@ -53152,8 +53140,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2, *result;
 
-       op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        do {
                int result;
 
@@ -53222,8 +53210,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                HashTable *ht;
@@ -53354,13 +53342,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM
        zval *offset;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
                ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        }
 
-       offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       offset = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
            ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
@@ -53397,8 +53385,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_
        zval *container, *dim, *value;
        zend_long offset;
 
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       container = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 fetch_dim_r_index_array:
                if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
@@ -53425,7 +53413,7 @@ fetch_dim_r_index_array:
        } else {
 fetch_dim_r_index_slow:
                SAVE_OPLINE();
-               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim);
+               zend_fetch_dimension_address_read_R_slow(EX_VAR(opline->result.var), container, dim EXECUTE_DATA_CC);
                zval_ptr_dtor_nogc(free_op1);
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        }

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 0eb56aece839664593350589e7d13080e55bae38..69c8e19c1a2f318257ac40f42fc90f742cafb297 100644 (file)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -236,221 +236,221 @@ $op2_free = array(
 );
 
 $op1_get_zval_ptr = array(
-       "ANY"      => "get_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "TMPVARCV" => "???",
 );
 
 $op2_get_zval_ptr = array(
-       "ANY"      => "get_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "TMPVARCV" => "???",
 );
 
 $op1_get_zval_ptr_ptr = array(
-       "ANY"      => "get_zval_ptr_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
+       "ANY"      => "get_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op2_get_zval_ptr_ptr = array(
-       "ANY"      => "get_zval_ptr_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
+       "ANY"      => "get_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op1_get_zval_ptr_deref = array(
-       "ANY"      => "get_zval_ptr_deref(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_zval_ptr_deref(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var)",
+       "CV"       => "_get_zval_ptr_cv_deref_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op2_get_zval_ptr_deref = array(
-       "ANY"      => "get_zval_ptr_deref(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_zval_ptr_deref(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var)",
+       "CV"       => "_get_zval_ptr_cv_deref_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op1_get_zval_ptr_undef = array(
-       "ANY"      => "get_zval_ptr_undef(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_undef(execute_data, opline->op1.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "CV"       => "_get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_zval_ptr_undef = array(
-       "ANY"      => "get_zval_ptr_undef(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_zval_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_undef(execute_data, opline->op2.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "CV"       => "_get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
 
 $op1_get_zval_ptr_ptr_undef = array(
-       "ANY"      => "get_zval_ptr_ptr_undef(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
+       "ANY"      => "get_zval_ptr_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var)",
+       "CV"       => "_get_zval_ptr_cv_undef_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_zval_ptr_ptr_undef = array(
-       "ANY"      => "get_zval_ptr_ptr_undef(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
+       "ANY"      => "get_zval_ptr_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var)",
+       "CV"       => "_get_zval_ptr_cv_undef_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
 
 $op1_get_obj_zval_ptr = array(
-       "ANY"      => "get_obj_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_obj_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "TMPVARCV" => "???",
 );
 
 $op2_get_obj_zval_ptr = array(
-       "ANY"      => "get_obj_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_obj_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "TMPVARCV" => "???",
 );
 
 $op1_get_obj_zval_ptr_undef = array(
-       "ANY"      => "get_obj_zval_ptr_undef(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_obj_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_undef(execute_data, opline->op1.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_obj_zval_ptr_undef = array(
-       "ANY"      => "get_obj_zval_ptr_undef(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_obj_zval_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_undef(execute_data, opline->op2.var)",
-       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
 
 $op1_get_obj_zval_ptr_deref = array(
-       "ANY"      => "get_obj_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)",
-       "VAR"      => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)",
+       "ANY"      => "get_obj_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op1)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_deref_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op2_get_obj_zval_ptr_deref = array(
-       "ANY"      => "get_obj_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)",
-       "VAR"      => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)",
+       "ANY"      => "get_obj_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT(opline->op2)",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_deref_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op1_get_obj_zval_ptr_ptr = array(
-       "ANY"      => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
+       "ANY"      => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op2_get_obj_zval_ptr_ptr = array(
-       "ANY"      => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
+       "ANY"      => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
 
 $op1_get_obj_zval_ptr_ptr_undef = array(
-       "ANY"      => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)",
+       "ANY"      => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_undef_\\1(opline->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_obj_zval_ptr_ptr_undef = array(
-       "ANY"      => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)",
+       "ANY"      => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
        "TMP"      => "NULL",
-       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
+       "VAR"      => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
        "CONST"    => "NULL",
-       "UNUSED"   => "_get_obj_zval_ptr_unused(execute_data)",
-       "CV"       => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var)",
+       "UNUSED"   => "_get_obj_zval_ptr_unused(EXECUTE_DATA_C)",
+       "CV"       => "_get_zval_ptr_cv_undef_\\1(opline->op2.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
@@ -555,23 +555,23 @@ $op_data_type = array(
 );
 
 $op_data_get_zval_ptr = array(
-       "ANY"      => "get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data)",
-       "VAR"      => "_get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data)",
+       "ANY"      => "get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT((opline+1)->op1)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_\\1(execute_data, (opline+1)->op1.var)",
-       "TMPVAR"   => "_get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data)",
+       "CV"       => "_get_zval_ptr_cv_\\1((opline+1)->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "_get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
        "TMPVARCV" => "???",
 );
 
 $op_data_get_zval_ptr_deref = array(
-       "ANY"      => "get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data, \\1)",
-       "TMP"      => "_get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data)",
-       "VAR"      => "_get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data)",
+       "ANY"      => "get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, \\1)",
+       "TMP"      => "_get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
+       "VAR"      => "_get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
        "CONST"    => "EX_CONSTANT((opline+1)->op1)",
        "UNUSED"   => "NULL",
-       "CV"       => "_get_zval_ptr_cv_deref_\\1(execute_data, (opline+1)->op1.var)",
+       "CV"       => "_get_zval_ptr_cv_deref_\\1((opline+1)->op1.var EXECUTE_DATA_CC)",
        "TMPVAR"   => "???",
        "TMPVARCV" => "???",
 );
@@ -831,7 +831,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                case ZEND_VM_KIND_CALL:
                        $code = preg_replace_callback(
                                array(
-                                       "/EXECUTE_DATA/m",
+                                       "/EXECUTE_DATA(?=[^_])/m",
                                        "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
                                        "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
                                ),
@@ -855,7 +855,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                case ZEND_VM_KIND_SWITCH:
                        $code = preg_replace_callback(
                                array(
-                                       "/EXECUTE_DATA/m",
+                                       "/EXECUTE_DATA(?=[^_])/m",
                                        "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
                                        "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
                                ),
@@ -879,7 +879,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                case ZEND_VM_KIND_GOTO:
                        $code = preg_replace_callback(
                                array(
-                                       "/EXECUTE_DATA/m",
+                                       "/EXECUTE_DATA(?=[^_])/m",
                                        "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
                                        "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
                                ),
@@ -1605,18 +1605,6 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name)
                                                        out($f,"#define HYBRID_DEFAULT    ZEND_NULL_LABEL\n");
                                                        out($f,"#endif\n");
                                                case ZEND_VM_KIND_CALL:
-                                                       out($f,"\n");
-                                                       out($f,"#ifdef ZEND_VM_FP_GLOBAL_REG\n");
-                                                       out($f,"#pragma GCC diagnostic ignored \"-Wvolatile-register-var\"\n");
-                                                       out($f,"register zend_execute_data* volatile execute_data __asm__(ZEND_VM_FP_GLOBAL_REG);\n");
-                                                       out($f,"#pragma GCC diagnostic warning \"-Wvolatile-register-var\"\n");
-                                                       out($f,"#endif\n");
-                                                       out($f,"\n");
-                                                       out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n");
-                                                       out($f,"#pragma GCC diagnostic ignored \"-Wvolatile-register-var\"\n");
-                                                       out($f,"register const zend_op* volatile opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n");
-                                                       out($f,"#pragma GCC diagnostic warning \"-Wvolatile-register-var\"\n");
-                                                       out($f,"#endif\n");
                                                        out($f,"\n");
                                                        out($f,"#ifdef ZEND_VM_FP_GLOBAL_REG\n");
                                                        out($f,"# define ZEND_OPCODE_HANDLER_ARGS void\n");