From 6e24feb80d53449c2a6aebcaac99b9a56d41b49d Mon Sep 17 00:00:00 2001
From: Dmitry Stogov <dmitry@php.net>
Date: Thu, 8 Jun 2006 08:37:51 +0000
Subject: [PATCH] Wrap "wrong" unreachable code with "#if 0"

---
 Zend/zend_vm_def.h     |  17 +-
 Zend/zend_vm_execute.h | 385 ++++++++++++++++++++++++++++++++---------
 Zend/zend_vm_gen.php   |   6 +-
 3 files changed, 322 insertions(+), 86 deletions(-)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index c9d93dbe2c..f1a7a68f02 100644
--- 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 7c8e6cc162..f7ea2a5c90 100644
--- 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 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]):""),
 		),
-- 
2.50.1