Improved ternary operator performance when returning arrays

8 files changed, 460 insertions, 15 deletions

diff --git a/NEWS b/NEWS
index 6fe03ac40f..9c8c2f5e71 100644
--- a/NEWS
+++ b/NEWS
@@ -3,6 +3,7 @@ PHP                                                                        NEWS
 ?? ??? 2011, PHP 5.4.0 RC1
 - General improvements:
   . Improve the warning message of incompatible arguments. (Laruence) 
+  . Improve ternary operator performance when returning arrays. (Arnaud, Dmitry)
   
 
 - Core:
diff --git a/Zend/micro_bench.php b/Zend/micro_bench.php
index 87a1b158c2..70525882eb 100644
--- a/Zend/micro_bench.php
+++ b/Zend/micro_bench.php
@@ -202,6 +202,35 @@ function read_str_offset($n) {
 	}
 }
 
+function issetor($n) {
+	$val = array(0,1,2,3,4,5,6,7,8,9);
+	for ($i = 0; $i < $n; ++$i) {
+		$x = $val ?: null;
+	}
+}
+
+function issetor2($n) {
+	$f = false; $j = 0;
+	for ($i = 0; $i < $n; ++$i) {
+		$x = $f ?: $j + 1;
+	}
+}
+
+function ternary($n) {
+	$val = array(0,1,2,3,4,5,6,7,8,9);
+	$f = false;
+	for ($i = 0; $i < $n; ++$i) {
+		$x = $f ? null : $val;
+	}
+}
+
+function ternary2($n) {
+	$f = false; $j = 0;
+	for ($i = 0; $i < $n; ++$i) {
+		$x = $f ? $f : $j + 1;
+	}
+}
+
 /*****/
 
 function empty_loop($n) {
@@ -318,4 +347,12 @@ read_hash(N);
 $t = end_test($t, '$x = $hash[\'v\']', $overhead);
 read_str_offset(N);
 $t = end_test($t, '$x = $str[0]', $overhead);
+issetor(N);
+$t = end_test($t, '$x = $a ?: null', $overhead);
+issetor2(N);
+$t = end_test($t, '$x = $f ?: tmp', $overhead);
+ternary(N);
+$t = end_test($t, '$x = $f ? $f : $a', $overhead);
+ternary2(N);
+$t = end_test($t, '$x = $f ? $f : tmp', $overhead);
 total($t0, "Total");
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index a9eb91a974..727380dac9 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1469,7 +1469,8 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
 			&& opline->result.var == op1->u.op.var) {
 			if (opline->opcode == ZEND_FETCH_R ||
 			    opline->opcode == ZEND_FETCH_DIM_R ||
-			    opline->opcode == ZEND_FETCH_OBJ_R) {
+			    opline->opcode == ZEND_FETCH_OBJ_R ||
+			    opline->opcode == ZEND_QM_ASSIGN_VAR) {
 				/* It's very rare and useless case. It's better to use
 				   additional FREE opcode and simplify the FETCH handlers
 				   their selves */
@@ -6308,8 +6309,13 @@ void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TS
 	int op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	opline->opcode = ZEND_JMP_SET;
-	opline->result_type = IS_TMP_VAR;
+	if (value->op_type == IS_VAR || value->op_type == IS_CV) {
+		opline->opcode = ZEND_JMP_SET_VAR;
+		opline->result_type = IS_VAR;
+	} else {
+		opline->opcode = ZEND_JMP_SET;
+		opline->result_type = IS_TMP_VAR;
+	}
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	SET_NODE(opline->op1, value);
 	SET_UNUSED(opline->op2);
@@ -6326,9 +6332,20 @@ void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	opline->opcode = ZEND_QM_ASSIGN;
-	opline->extended_value = 0;
 	SET_NODE(opline->result, colon_token);
+	if (colon_token->op_type == IS_TMP_VAR) {
+		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
+			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR;
+			CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR;
+			opline->opcode = ZEND_QM_ASSIGN_VAR;
+			opline->result_type = IS_VAR;
+		} else {
+			opline->opcode = ZEND_QM_ASSIGN;
+		}
+	} else {
+		opline->opcode = ZEND_QM_ASSIGN_VAR;
+	}
+	opline->extended_value = 0;
 	SET_NODE(opline->op1, false_value);
 	SET_UNUSED(opline->op2);
 	
@@ -6363,8 +6380,13 @@ void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_toke
 
 	CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
 
-	opline->opcode = ZEND_QM_ASSIGN;
-	opline->result_type = IS_TMP_VAR;
+	if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) {
+		opline->opcode = ZEND_QM_ASSIGN_VAR;
+		opline->result_type = IS_VAR;
+	} else {
+		opline->opcode = ZEND_QM_ASSIGN;
+		opline->result_type = IS_TMP_VAR;
+	}
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	SET_NODE(opline->op1, true_value);
 	SET_UNUSED(opline->op2);
@@ -6383,8 +6405,19 @@ void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_t
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
-	opline->opcode = ZEND_QM_ASSIGN;
 	SET_NODE(opline->result, qm_token);
+	if (qm_token->op_type == IS_TMP_VAR) {
+		if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) {
+			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR;
+			CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR;
+			opline->opcode = ZEND_QM_ASSIGN_VAR;
+			opline->result_type = IS_VAR;
+		} else {
+			opline->opcode = ZEND_QM_ASSIGN;
+		}
+	} else {
+		opline->opcode = ZEND_QM_ASSIGN_VAR;
+	}
 	SET_NODE(opline->op1, false_value);
 	SET_UNUSED(opline->op2);
 
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 5ae15f40e0..888058de98 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -1299,6 +1299,7 @@ void execute_new_code(TSRMLS_D) /* {{{ */
 			case ZEND_JMPZ_EX:
 			case ZEND_JMPNZ_EX:
 			case ZEND_JMP_SET:
+			case ZEND_JMP_SET_VAR:
 				opline->op2.jmp_addr = &CG(active_op_array)->opcodes[opline->op2.opline_num];
 				break;
 		}
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 9d4f3e715f..65b9aa5fc0 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -529,6 +529,7 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
 			case ZEND_JMPZ_EX:
 			case ZEND_JMPNZ_EX:
 			case ZEND_JMP_SET:
+			case ZEND_JMP_SET_VAR:
 				opline->op2.jmp_addr = &op_array->opcodes[opline->op2.opline_num];
 				break;
 		}
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 4e944a1350..238864ec7a 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4661,8 +4661,45 @@ ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
 
 	if (i_zend_is_true(value)) {
 		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
-		zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
-		FREE_OP1();
+		if (!IS_OP1_TMP_FREE()) {
+			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		}
+		FREE_OP1_IF_VAR();
+#if DEBUG_ZEND>=2
+		printf("Conditional jmp to %d\n", opline->op2.opline_num);
+#endif
+		ZEND_VM_JMP(opline->op2.jmp_addr);
+	}
+
+	FREE_OP1();
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(158, ZEND_JMP_SET_VAR, CONST|TMP|VAR|CV, ANY)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
+
+	if (i_zend_is_true(value)) {
+		if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
+			Z_ADDREF_P(value);
+			EX_T(opline->result.var).var.ptr = value;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+		} else {
+			ALLOC_ZVAL(ret);
+			INIT_PZVAL_COPY(ret, value);
+			EX_T(opline->result.var).var.ptr = ret;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+			if (!IS_OP1_TMP_FREE()) {
+				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			}
+		}
+		FREE_OP1_IF_VAR();
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
 #endif
@@ -4692,6 +4729,34 @@ ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(157, ZEND_QM_ASSIGN_VAR, CONST|TMP|VAR|CV, ANY)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
+
+	if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
+		Z_ADDREF_P(value);
+		EX_T(opline->result.var).var.ptr = value;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+	} else {
+		ALLOC_ZVAL(ret);
+		INIT_PZVAL_COPY(ret, value);
+		EX_T(opline->result.var).var.ptr = ret;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+		if (!IS_OP1_TMP_FREE()) {
+			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+		}
+	}
+
+	FREE_OP1_IF_VAR();
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 ZEND_VM_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
 {
 	SAVE_OPLINE();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index af40d57d0e..d90053a55e 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2836,7 +2836,43 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 
 	if (i_zend_is_true(value)) {
 		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
-		zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		if (!0) {
+			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		}
+
+#if DEBUG_ZEND>=2
+		printf("Conditional jmp to %d\n", opline->op2.opline_num);
+#endif
+		ZEND_VM_JMP(opline->op2.jmp_addr);
+	}
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = opline->op1.zv;
+
+	if (i_zend_is_true(value)) {
+		if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+			Z_ADDREF_P(value);
+			EX_T(opline->result.var).var.ptr = value;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+		} else {
+			ALLOC_ZVAL(ret);
+			INIT_PZVAL_COPY(ret, value);
+			EX_T(opline->result.var).var.ptr = ret;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+			if (!0) {
+				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			}
+		}
 
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -2866,6 +2902,33 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = opline->op1.zv;
+
+	if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+		Z_ADDREF_P(value);
+		EX_T(opline->result.var).var.ptr = value;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+	} else {
+		ALLOC_ZVAL(ret);
+		INIT_PZVAL_COPY(ret, value);
+		EX_T(opline->result.var).var.ptr = ret;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+		if (!0) {
+			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+		}
+	}
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -7132,8 +7195,45 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 	if (i_zend_is_true(value)) {
 		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
-		zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
-		zval_dtor(free_op1.var);
+		if (!1) {
+			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		}
+
+#if DEBUG_ZEND>=2
+		printf("Conditional jmp to %d\n", opline->op2.opline_num);
+#endif
+		ZEND_VM_JMP(opline->op2.jmp_addr);
+	}
+
+	zval_dtor(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+	if (i_zend_is_true(value)) {
+		if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+			Z_ADDREF_P(value);
+			EX_T(opline->result.var).var.ptr = value;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+		} else {
+			ALLOC_ZVAL(ret);
+			INIT_PZVAL_COPY(ret, value);
+			EX_T(opline->result.var).var.ptr = ret;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+			if (!1) {
+				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			}
+		}
+
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
 #endif
@@ -7163,6 +7263,33 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+	if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+		Z_ADDREF_P(value);
+		EX_T(opline->result.var).var.ptr = value;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+	} else {
+		ALLOC_ZVAL(ret);
+		INIT_PZVAL_COPY(ret, value);
+		EX_T(opline->result.var).var.ptr = ret;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+		if (!1) {
+			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+		}
+	}
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -11539,7 +11666,44 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 	if (i_zend_is_true(value)) {
 		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
-		zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		if (!0) {
+			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		}
+		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+#if DEBUG_ZEND>=2
+		printf("Conditional jmp to %d\n", opline->op2.opline_num);
+#endif
+		ZEND_VM_JMP(opline->op2.jmp_addr);
+	}
+
+	if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+	if (i_zend_is_true(value)) {
+		if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+			Z_ADDREF_P(value);
+			EX_T(opline->result.var).var.ptr = value;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+		} else {
+			ALLOC_ZVAL(ret);
+			INIT_PZVAL_COPY(ret, value);
+			EX_T(opline->result.var).var.ptr = ret;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+			if (!0) {
+				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			}
+		}
 		if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -11570,6 +11734,34 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+		Z_ADDREF_P(value);
+		EX_T(opline->result.var).var.ptr = value;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+	} else {
+		ALLOC_ZVAL(ret);
+		INIT_PZVAL_COPY(ret, value);
+		EX_T(opline->result.var).var.ptr = ret;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+		if (!0) {
+			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+		}
+	}
+
+	if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -27127,7 +27319,43 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 	if (i_zend_is_true(value)) {
 		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
-		zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		if (!0) {
+			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+		}
+
+#if DEBUG_ZEND>=2
+		printf("Conditional jmp to %d\n", opline->op2.opline_num);
+#endif
+		ZEND_VM_JMP(opline->op2.jmp_addr);
+	}
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+	if (i_zend_is_true(value)) {
+		if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+			Z_ADDREF_P(value);
+			EX_T(opline->result.var).var.ptr = value;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+		} else {
+			ALLOC_ZVAL(ret);
+			INIT_PZVAL_COPY(ret, value);
+			EX_T(opline->result.var).var.ptr = ret;
+			EX_T(opline->result.var).var.ptr_ptr = NULL;
+			if (!0) {
+				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			}
+		}
 
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -27157,6 +27385,33 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *value, *ret;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+		Z_ADDREF_P(value);
+		EX_T(opline->result.var).var.ptr = value;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+	} else {
+		ALLOC_ZVAL(ret);
+		INIT_PZVAL_COPY(ret, value);
+		EX_T(opline->result.var).var.ptr = ret;
+		EX_T(opline->result.var).var.ptr_ptr = NULL;
+		if (!0) {
+			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+		}
+	}
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -39759,6 +40014,56 @@ void zend_init_opcodes_handlers(void)
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
+  	ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
+  	ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
   	ZEND_NULL_HANDLER
   };
   zend_opcode_handlers = (opcode_handler_t*)labels;
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index ed80ddc7a5..9b76b0eb34 100644
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -157,3 +157,5 @@
 #define ZEND_ADD_TRAIT                       154
 #define ZEND_BIND_TRAITS                     155
 #define ZEND_SEPARATE                        156
+#define ZEND_QM_ASSIGN_VAR                   157
+#define ZEND_JMP_SET_VAR                     158