From bfa154448df7d4355fda07d586cb59908273fb4e Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Fri, 16 Jun 2017 01:42:49 +0300 Subject: [PATCH] VM refactoring, to avoid passing "execute_data" into helper functions that can access it using global register variable. --- Zend/zend_execute.c | 346 +++-- Zend/zend_vm_def.h | 74 +- Zend/zend_vm_execute.h | 3026 ++++++++++++++++++++-------------------- Zend/zend_vm_gen.php | 216 ++- 4 files changed, 1837 insertions(+), 1825 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 1174c13401f..715808632ec 100644 --- 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 7ba80a8bd62..d0f37111857 100644 --- 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 e9500a79b26..4773320344d 100644 --- 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 0eb56aece83..69c8e19c1a2 100644 --- 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");