Wrap "wrong" unreachable code with "#if 0"

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index b7e57c7318f390646c1cee906df7006236b9ed41..0db6bcda8e1a4cfaaea418a21c3e1c3708ea547d 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2595,15 +2595,21 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=GET_OP2_ZVAL_PTR(BP_VAR_R);
 
+#if !defined(ZEND_VM_SPEC) || OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
        }
+#else
+       expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -2611,18 +2617,21 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && IS_OP1_TMP_FREE()) { /* temporary variable */
+       if (IS_OP1_TMP_FREE()) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if !defined(ZEND_VM_SPEC) || OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else 
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -3570,7 +3579,7 @@ ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|C
 
 ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
 {
-#ifdef ZEND_OP1_USED
+#if !defined(ZEND_VM_SPEC) || (OP1_TYPE != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (OP1_TYPE != IS_UNUSED) {
                zend_free_op free_op1;

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index b414f747e5623f2d5e772d3893afe4623239c15b..cfb01b12a5961b67ae23ed0666551177eb2bd499 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2229,7 +2229,7 @@ static int ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-#if 1
+#if 0 || (IS_CONST != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_CONST != IS_UNUSED) {
 
@@ -2622,15 +2622,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
 
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=&opline->op1.u.constant;
        }
+#else
+       expr_ptr=&opline->op1.u.constant;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -2638,18 +2644,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -2970,15 +2979,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=&opline->op1.u.constant;
        }
+#else
+       expr_ptr=&opline->op1.u.constant;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -2986,18 +3001,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -3318,15 +3336,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=&opline->op1.u.constant;
        }
+#else
+       expr_ptr=&opline->op1.u.constant;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -3334,18 +3358,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -3400,15 +3427,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=NULL;
 
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=&opline->op1.u.constant;
        }
+#else
+       expr_ptr=&opline->op1.u.constant;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -3416,18 +3449,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -3747,15 +3783,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=&opline->op1.u.constant;
        }
+#else
+       expr_ptr=&opline->op1.u.constant;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -3763,18 +3805,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CONST == IS_VAR || IS_CONST == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -4738,7 +4783,7 @@ static int ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-#if 1
+#if 0 || (IS_TMP_VAR != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op1;
@@ -5212,15 +5257,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
 
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -5228,18 +5279,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 1) { /* temporary variable */
+       if (1) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -5648,15 +5702,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -5664,18 +5724,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 1) { /* temporary variable */
+       if (1) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -6084,15 +6147,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -6100,18 +6169,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 1) { /* temporary variable */
+       if (1) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -6166,15 +6238,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=NULL;
 
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -6182,18 +6260,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 1) { /* temporary variable */
+       if (1) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -6599,15 +6680,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -6615,18 +6702,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 1) { /* temporary variable */
+       if (1) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -7994,7 +8084,7 @@ static int ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-#if 1
+#if 0 || (IS_VAR != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op1;
@@ -9170,15 +9260,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
 
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -9186,18 +9282,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -10652,15 +10751,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -10668,18 +10773,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -12172,15 +12280,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -12188,18 +12302,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -12890,15 +13007,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=NULL;
 
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -12906,18 +13029,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -14095,15 +14221,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op1;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -14111,18 +14243,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_VAR == IS_VAR || IS_VAR == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -14537,7 +14672,7 @@ static int ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-#if 0
+#if 0 || (IS_UNUSED != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_UNUSED != IS_UNUSED) {
 
@@ -15306,15 +15441,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
 
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=NULL;
        }
+#else
+       expr_ptr=NULL;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -15322,18 +15463,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -16399,15 +16543,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=NULL;
        }
+#else
+       expr_ptr=NULL;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -16415,18 +16565,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -17492,15 +17645,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=NULL;
        }
+#else
+       expr_ptr=NULL;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -17508,18 +17667,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -18164,15 +18326,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=NULL;
 
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=NULL;
        }
+#else
+       expr_ptr=NULL;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -18180,18 +18348,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -18949,15 +19120,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=NULL;
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=NULL;
        }
+#else
+       expr_ptr=NULL;
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -18965,18 +19142,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -20479,7 +20659,7 @@ static int ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-#if 1
+#if 0 || (IS_CV != IS_UNUSED)
        zend_op *opline = EX(opline);
        if (IS_CV != IS_UNUSED) {
 
@@ -21651,15 +21831,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=&opline->op2.u.constant;
 
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -21667,18 +21853,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -23125,15 +23314,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -23141,18 +23336,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -24636,15 +24834,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
        zend_free_op free_op2;
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
 
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -24652,18 +24856,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -25349,15 +25556,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=NULL;
 
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -25365,18 +25578,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);
@@ -26549,15 +26765,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_op *opline = EX(opline);
 
        zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr, **expr_ptr_ptr = NULL;
+       zval *expr_ptr;
        zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
 
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
+       zval **expr_ptr_ptr = NULL;
+
        if (opline->extended_value) {
                expr_ptr_ptr=_get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
                expr_ptr = *expr_ptr_ptr;
        } else {
                expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        }
+#else
+       expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+#endif
 
        if (opline->opcode == ZEND_INIT_ARRAY) {
                array_init(array_ptr);
@@ -26565,18 +26787,21 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        ZEND_VM_NEXT_OPCODE();
                }
        }
-       if (!opline->extended_value && 0) { /* temporary variable */
+       if (0) { /* temporary variable */
                zval *new_expr;
 
                ALLOC_ZVAL(new_expr);
                INIT_PZVAL_COPY(new_expr, expr_ptr);
                expr_ptr = new_expr;
        } else {
+#if 0 || IS_CV == IS_VAR || IS_CV == IS_CV
                if (opline->extended_value) {
                        SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
                        expr_ptr = *expr_ptr_ptr;
                        expr_ptr->refcount++;
-               } else if (PZVAL_IS_REF(expr_ptr)) {
+               } else
+#endif
+               if (PZVAL_IS_REF(expr_ptr)) {
                        zval *new_expr;
 
                        ALLOC_ZVAL(new_expr);

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index edfb7265b8e3eba53d97355f882cd47cd3d874fe..e81597d6afa99cf77eb9119feb25dc4830265054 100644 (file)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -338,7 +338,8 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2) {
                        "/FREE_OP2_VAR_PTR\(\)/",
                        "/^#ifdef\s+ZEND_VM_SPEC\s*\n/m",
                        "/^#ifndef\s+ZEND_VM_SPEC\s*\n/m",
-                       "/^#ifdef\s+ZEND_OP1_USED\s*\n/m",
+                       "/\!defined\(ZEND_VM_SPEC\)/m",
+                       "/defined\(ZEND_VM_SPEC\)/m",
                        "/ZEND_VM_C_LABEL\(\s*([A-Za-z_]*)\s*\)/m",
                        "/ZEND_VM_C_GOTO\(\s*([A-Za-z_]*)\s*\)/m",
                ),
@@ -365,7 +366,8 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2) {
                        $op2_free_op_var_ptr[$op2],
                        ($op1!="ANY"||$op2!="ANY")?"#if 1\n":"#if 0\n",
                        ($op1!="ANY"||$op2!="ANY")?"#if 0\n":"#if 1\n",
-                       ($op1!="UNUSED")?"#if 1\n":"#if 0\n",
+                       ($op1!="ANY"||$op2!="ANY")?"0":"1",
+                       ($op1!="ANY"||$op2!="ANY")?"1":"0",
                        "\\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
                        "goto \\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2]):""),
                ),