]> granicus.if.org Git - php/commitdiff
Use CV variable offset instead of CV variable number
authorDmitry Stogov <dmitry@zend.com>
Thu, 27 Mar 2014 12:00:25 +0000 (16:00 +0400)
committerDmitry Stogov <dmitry@zend.com>
Thu, 27 Mar 2014 12:00:25 +0000 (16:00 +0400)
Zend/zend_compile.c
Zend/zend_compile.h
Zend/zend_execute.c
Zend/zend_execute_API.c
Zend/zend_opcode.c
Zend/zend_vm_def.h
Zend/zend_vm_execute.h

index b9193303455508f1dc79fba2d7e47daeb33ffd96..807ebd508e714885eb8958f7bcaa3921c3ad9037 100644 (file)
@@ -314,7 +314,7 @@ static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{
                     op_array->vars[i]->len == name->len &&
                     memcmp(op_array->vars[i]->val, name->val, name->len) == 0)) {
                        STR_RELEASE(name);
-                       return i;
+                       return (int)EX_VAR_NUM_2(NULL, i);
                }
                i++;
        }
@@ -326,7 +326,7 @@ static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{
        }
 
        op_array->vars[i] = zend_new_interned_string(name TSRMLS_CC);
-       return i;
+       return (int)EX_VAR_NUM_2(NULL, i);
 }
 /* }}} */
 
@@ -681,7 +681,7 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
                     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
                        result->op_type = IS_CV;
                        result->u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
-                       Z_STR(varname->u.constant) = CG(active_op_array)->vars[result->u.op.var];
+                       Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)];
                        result->EA = 0;
                        return;
                }
@@ -745,7 +745,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
                opline.result_type = IS_VAR;
                opline.result.var = get_temporary_variable(CG(active_op_array));
                opline.op1_type = IS_CONST;
-               LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[result->u.op.var]));
+               LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]));
                GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
                if (class_node.op_type == IS_CONST) {
                        opline.op2_type = IS_CONST;
@@ -769,7 +769,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
                        opline.result_type = IS_VAR;
                        opline.result.var = get_temporary_variable(CG(active_op_array));
                        opline.op1_type = IS_CONST;
-                       LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[opline_ptr->op1.var]));
+                       LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)]));
                        GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
                        if (class_node.op_type == IS_CONST) {
                                opline.op2_type = IS_CONST;
@@ -946,7 +946,7 @@ void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {
                                opline->result.var = get_temporary_variable(CG(active_op_array));
                                opline->op1_type = IS_CONST;
                                LITERAL_STR(opline->op1,
-                                       STR_COPY(CG(active_op_array)->vars[value->u.op.var]));
+                                       STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)]));
                                SET_UNUSED(opline->op2);
                                opline->extended_value = ZEND_FETCH_LOCAL;
                                GET_NODE(value, opline->result);
@@ -1856,7 +1856,7 @@ void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initializ
        } else {
                var.op_type = IS_CV;
                var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
-               Z_STR(varname->u.constant) = CG(active_op_array)->vars[var.u.op.var];
+               Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)];
                var.EA = 0;
                if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL &&
                        Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
@@ -2998,7 +2998,7 @@ void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var
        opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
        opline->op2_type = IS_CV;
        opline->op2.var = lookup_cv(CG(active_op_array), Z_STR(catch_var->u.constant) TSRMLS_CC);
-       Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[opline->op2.var];
+       Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(opline->op2.var)];
        opline->result.num = 0; /* 1 means it's the last catch in the block */
 
        catch_token->u.op.opline_num = catch_op_number;
@@ -7002,7 +7002,7 @@ int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{
 
 ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var) /* {{{ */
 {
-       return op_array->vars[var];
+       return op_array->vars[EX_VAR_TO_NUM(var)];
 }
 /* }}} */
 
index e48f5e57c9eebde66dfc86f09c4a3bf98f55c16c..3aacbff99335370d6405fb4642e833c612bcee23 100644 (file)
@@ -402,6 +402,8 @@ struct _zend_execute_data {
 #define EX_VAR(n)                              EX_VAR_2(execute_data, n)
 #define EX_VAR_NUM(n)                  EX_VAR_NUM_2(execute_data, n)
 
+#define EX_VAR_TO_NUM(n)               (EX_VAR_2(NULL, n) - EX_VAR_NUM_2(NULL, 0))
+
 #define IS_CONST       (1<<0)
 #define IS_TMP_VAR     (1<<1)
 #define IS_VAR         (1<<2)
index 666676ae09722ab991146d1e77ff94ea34006f53..2852d17af4c52c504c3cc6bb5bbfa38178a3b45f 100644 (file)
@@ -168,7 +168,7 @@ static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
 
 ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data, zend_uint var)
 {
-       return EX_VAR_NUM(var);
+       return EX_VAR(var);
 }
 
 static zend_always_inline zval *_get_zval_ptr_tmp(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
@@ -209,14 +209,14 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_UNSET:
-                       cv = CV_DEF_OF(var);
+                       cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
                        zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
                        /* break missing intentionally */
                case BP_VAR_IS:
                        ptr = &EG(uninitialized_zval);
                        break;
                case BP_VAR_RW:
-                       cv = CV_DEF_OF(var);
+                       cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
                        zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
                        /* break missing intentionally */
                case BP_VAR_W:
@@ -228,7 +228,7 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, zend_uint var TSRMLS_DC)
 {
-       zend_string *cv = CV_DEF_OF(var);
+       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
        zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
        return &EG(uninitialized_zval);
@@ -236,7 +236,7 @@ static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, zend_uin
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, zend_uint var TSRMLS_DC)
 {
-       zend_string *cv = CV_DEF_OF(var);
+       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
        zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
        return &EG(uninitialized_zval);
@@ -249,7 +249,7 @@ static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_IS(zval *ptr, zend_ui
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, zend_uint var TSRMLS_DC)
 {
-       zend_string *cv = CV_DEF_OF(var);
+       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
        ZVAL_NULL(ptr);
        zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
@@ -262,9 +262,9 @@ static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, zend_uin
        return ptr;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv(zend_uint var, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv(const zend_execute_data *execute_data, zend_uint var, int type TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM_2(EG(current_execute_data), var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
@@ -272,9 +272,9 @@ static zend_always_inline zval *_get_zval_ptr_cv(zend_uint var, int type TSRMLS_
        return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_deref(zend_uint var, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref(const zend_execute_data *execute_data, zend_uint var, int type TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM_2(EG(current_execute_data), var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
@@ -285,7 +285,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref(zend_uint var, int type T
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
@@ -295,7 +295,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(const zend_execute_dat
 
 static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
@@ -306,7 +306,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(const zend_execu
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
@@ -316,7 +316,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute
 
 static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
@@ -327,7 +327,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(const zend_e
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
                return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
@@ -337,7 +337,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_da
 
 static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
                return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
@@ -348,7 +348,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_exec
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
@@ -358,7 +358,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_da
 
 static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
                return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
@@ -369,7 +369,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(const zend_exec
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
                return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
@@ -379,7 +379,7 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_dat
 
 static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-       zval *ret = EX_VAR_NUM(var);
+       zval *ret = EX_VAR(var);
 
        if (Z_TYPE_P(ret) == IS_UNDEF) {
                return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
@@ -411,7 +411,7 @@ static inline zval *_get_zval_ptr(int op_type, const znode_op *node, const zend_
                        break;
                case IS_CV:
                        should_free->var = NULL;
-                       return _get_zval_ptr_cv(node->var, type TSRMLS_CC);
+                       return _get_zval_ptr_cv(execute_data, node->var, type TSRMLS_CC);
                        break;
                EMPTY_SWITCH_DEFAULT_CASE()
        }
@@ -441,7 +441,7 @@ static inline zval *_get_zval_ptr_deref(int op_type, const znode_op *node, const
                        break;
                case IS_CV:
                        should_free->var = NULL;
-                       return _get_zval_ptr_cv_deref(node->var, type TSRMLS_CC);
+                       return _get_zval_ptr_cv_deref(execute_data, node->var, type TSRMLS_CC);
                        break;
                EMPTY_SWITCH_DEFAULT_CASE()
        }
@@ -1455,7 +1455,7 @@ void zend_clean_and_cache_symbol_table(zend_array *symbol_table TSRMLS_DC) /* {{
 
 static zend_always_inline void i_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC) /* {{{ */
 {
-       zval *cv = EX_VAR_NUM_2(execute_data, 0);
+       zval *cv = EX_VAR_NUM(0);
        zval *end = cv + EX(op_array)->last_var;
        while (cv != end) {
                zval_ptr_dtor(cv);
@@ -1573,7 +1573,7 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
                EX(prev_execute_data) = EG(current_execute_data);
        }
 
-       memset(EX_VAR_NUM_2(execute_data, 0), 0, sizeof(zval) * op_array->last_var);
+       memset(EX_VAR_NUM(0), 0, sizeof(zval) * op_array->last_var);
 
        EX(call_slots) = (call_slot*)((char *)execute_data + execute_data_size + vars_size);
 
@@ -1601,7 +1601,7 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
        }
 
        if (op_array->this_var != -1 && Z_TYPE(EG(This)) != IS_UNDEF) {
-               ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
+               ZVAL_COPY(EX_VAR(op_array->this_var), &EG(This));
        }
 
        EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
index 7e41512ad20d4b9230fef2ed96ff7a14c18c8f5c..c0b61b820ba58eff934d8548e2a2c2fe02cf5478 100644 (file)
@@ -1696,9 +1696,9 @@ ZEND_API void zend_rebuild_symbol_table(TSRMLS_D) /* {{{ */
                        ex->symbol_table = EG(active_symbol_table);
 
                        if (ex->op_array->this_var != -1 &&
-                           Z_TYPE_P(EX_VAR_NUM_2(ex, ex->op_array->this_var)) == IS_UNDEF &&
+                           Z_TYPE_P(EX_VAR_2(ex, ex->op_array->this_var)) == IS_UNDEF &&
                            Z_TYPE(EG(This)) != IS_UNDEF) {
-                           ZVAL_COPY_VALUE(EX_VAR_NUM_2(ex, ex->op_array->this_var), &EG(This));
+                           ZVAL_COPY_VALUE(EX_VAR_2(ex, ex->op_array->this_var), &EG(This));
                        }
                        for (i = 0; i < ex->op_array->last_var; i++) {
                                zval zv;
index 222baae0d5c4d7ce46d6f7af394abfd734f6c149..039c3bbd7646cd79ceebe161708b6db59c578e17 100644 (file)
@@ -697,7 +697,6 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
                op_array->literals = (zend_literal*)erealloc(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
                CG(context).literals_size = op_array->last_literal;
        }
-
        opline = op_array->opcodes;
        end = opline + op_array->last;
        while (opline < end) {
index f0d30d7e49d63a045f57ac23d54611e8043778be..8919597f185306d1e4ff6824ba3fc2fc7e3c8512 100644 (file)
@@ -3016,10 +3016,10 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
        }
 
        exception = EG(exception);
-       if (Z_REFCOUNTED_P(EX_VAR_NUM(opline->op2.var))) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op2.var));
+       if (Z_REFCOUNTED_P(EX_VAR(opline->op2.var))) {
+               zval_ptr_dtor(EX_VAR(opline->op2.var));
        }
-       ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
+       ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
        if (UNEXPECTED(EG(exception) != exception)) {
                EG(exception)->gc.refcount++;
                HANDLE_EXCEPTION();
@@ -4038,8 +4038,8 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
        if (OP1_TYPE == IS_CV &&
            OP2_TYPE == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -4567,8 +4567,8 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
        if (OP1_TYPE == IS_CV &&
            OP2_TYPE == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
index 85cf30504f67ed719fb810f3a834dbefd5e5714a..6dca7f02d5ab3308531bedf2f51863b675d1caf9 100644 (file)
@@ -4062,8 +4062,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
        if (IS_CONST == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -4129,8 +4129,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
        if (IS_CONST == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -5719,8 +5719,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
        if (IS_CONST == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -5786,8 +5786,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
        if (IS_CONST == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -6387,8 +6387,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
        if (IS_CONST == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -6454,8 +6454,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
        if (IS_CONST == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -7125,10 +7125,10 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
        }
 
        exception = EG(exception);
-       if (Z_REFCOUNTED_P(EX_VAR_NUM(opline->op2.var))) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op2.var));
+       if (Z_REFCOUNTED_P(EX_VAR(opline->op2.var))) {
+               zval_ptr_dtor(EX_VAR(opline->op2.var));
        }
-       ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
+       ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
        if (UNEXPECTED(EG(exception) != exception)) {
                EG(exception)->gc.refcount++;
                HANDLE_EXCEPTION();
@@ -9072,8 +9072,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
        if (IS_TMP_VAR == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -9139,8 +9139,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
        if (IS_TMP_VAR == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -10704,8 +10704,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
        if (IS_TMP_VAR == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -10771,8 +10771,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
        if (IS_TMP_VAR == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -11261,8 +11261,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
        if (IS_TMP_VAR == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -11328,8 +11328,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
        if (IS_TMP_VAR == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -15475,8 +15475,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
        if (IS_VAR == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -15689,8 +15689,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
        if (IS_VAR == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -19955,8 +19955,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
        if (IS_VAR == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -20169,8 +20169,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
        if (IS_VAR == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -21355,8 +21355,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
        if (IS_VAR == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -21422,8 +21422,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
        if (IS_VAR == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -32379,8 +32379,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
        if (IS_CV == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -32591,8 +32591,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
        if (IS_CV == IS_CV &&
            IS_CONST == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -36608,8 +36608,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
        if (IS_CV == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -36820,8 +36820,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
        if (IS_CV == IS_CV &&
            IS_VAR == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;
@@ -37888,8 +37888,8 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
        if (IS_CV == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
-               ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
+               zval_ptr_dtor(EX_VAR(opline->op1.var));
+               ZVAL_UNDEF(EX_VAR(opline->op1.var));
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        }
@@ -37955,8 +37955,8 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
        if (IS_CV == IS_CV &&
            IS_UNUSED == IS_UNUSED &&
            (opline->extended_value & ZEND_QUICK_SET)) {
-               if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
-                       value = EX_VAR_NUM(opline->op1.var);
+               if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+                       value = EX_VAR(opline->op1.var);
                        ZVAL_DEREF(value);
                } else {
                        isset = 0;