From: Dmitry Stogov <dmitry@php.net>
Date: Thu, 8 Jun 2006 08:38:11 +0000 (+0000)
Subject: Wrap "wrong" unreachable code with "#if 0"
X-Git-Tag: RELEASE_1_0_0RC1~2758
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=de90af4ddcccad283338782c8e89d640ac03ad4d;p=php

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

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index b7e57c7318..0db6bcda8e 100644
--- 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 b414f747e5..cfb01b12a5 100644
--- 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 edfb7265b8..e81597d6af 100644
--- 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]):""),
 		),