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

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index c9d93dbe2c2ce835b6d2c80c42e76d963653d2e5..f1a7a68f02fc9d6e558a5991986c37dbc232eb3e 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2563,15 +2563,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);
@@ -2579,18 +2585,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);
@@ -3457,7 +3466,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 7c8e6cc16248c28331e07c83d51ac75eda260c2f..f7ea2a5c90efabdf1ddc5ce35469702d0ab2da88 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2262,7 +2262,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) {
 
@@ -2618,15 +2618,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);
@@ -2634,18 +2640,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);
@@ -2965,15 +2974,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);
@@ -2981,18 +2996,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);
@@ -3312,15 +3330,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);
@@ -3328,18 +3352,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);
@@ -3393,15 +3420,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);
@@ -3409,18 +3442,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);
@@ -3739,15 +3775,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);
@@ -3755,18 +3797,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);
@@ -4715,7 +4760,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;
@@ -5152,15 +5197,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);
@@ -5168,18 +5219,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);
@@ -5582,15 +5636,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);
@@ -5598,18 +5658,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);
@@ -6012,15 +6075,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);
@@ -6028,18 +6097,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);
@@ -6093,15 +6165,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);
@@ -6109,18 +6187,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);
@@ -6520,15 +6601,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);
@@ -6536,18 +6623,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);
@@ -7890,7 +7980,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;
@@ -9029,15 +9119,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);
@@ -9045,18 +9141,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);
@@ -10455,15 +10554,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);
@@ -10471,18 +10576,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);
@@ -11919,15 +12027,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);
@@ -11935,18 +12049,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);
@@ -12583,15 +12700,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);
@@ -12599,18 +12722,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);
@@ -13785,15 +13911,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);
@@ -13801,18 +13933,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);
@@ -14173,7 +14308,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) {
 
@@ -14938,15 +15073,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);
@@ -14954,18 +15095,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);
@@ -15975,15 +16119,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);
@@ -15991,18 +16141,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);
@@ -17012,15 +17165,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);
@@ -17028,18 +17187,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);
@@ -17630,15 +17792,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);
@@ -17646,18 +17814,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);
@@ -18412,15 +18583,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);
@@ -18428,18 +18605,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);
@@ -19874,7 +20054,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) {
 
@@ -21009,15 +21189,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);
@@ -21025,18 +21211,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);
@@ -22427,15 +22616,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);
@@ -22443,18 +22638,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);
@@ -23882,15 +24080,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);
@@ -23898,18 +24102,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);
@@ -24541,15 +24748,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);
@@ -24557,18 +24770,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);
@@ -25738,15 +25954,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);
@@ -25754,18 +25976,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]):""),
                ),