Improved BOOL, BOOL_NOT and conditional jumps

2 files changed, 525 insertions, 665 deletions

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 5d757d5a45..b2e6c96b35 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -313,16 +313,23 @@ ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
+	zval *val;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_not_function(EX_VAR(opline->result.var),
-		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
-	FREE_OP1();
-	CHECK_EXCEPTION();
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	if (Z_TYPE_P(val) == IS_TRUE) {			
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val TSRMLS_CC));
+		FREE_OP1();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -441,7 +448,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 		}
 		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
 	} else {
-		zval *dim = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
+		zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -1844,20 +1851,22 @@ ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY)
 	ZEND_VM_CONTINUE();
 }
 
-ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *val;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {			
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {			
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (OP1_TYPE == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {			
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -1875,20 +1884,22 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_JMP(opline);
 }
 
-ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *val;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (OP1_TYPE == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {			
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -1906,20 +1917,22 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_JMP(opline);
 }
 
-ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *val;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR) {
-		if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
-			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (OP1_TYPE == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {			
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -1937,22 +1950,24 @@ ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_JMP(opline);
 }
 
-ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *val;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (OP1_TYPE == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {			
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -1973,22 +1988,24 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 	ZEND_VM_JMP(opline);
 }
 
-ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *val;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (OP1_TYPE == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {			
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -2512,11 +2529,11 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 	}
 }
 
-ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *function_name = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
+	zval *function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 	zend_fcall_info_cache fcc;
 	char *error = NULL;
 	zend_function *func;
@@ -3599,15 +3616,20 @@ ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, ANY, ANY)
 ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
 {
 	USE_OPLINE
+	zval *val;
 	zend_free_op free_op1;
-	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	ZVAL_BOOL(retval, i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
-	FREE_OP1();
-
-	CHECK_EXCEPTION();
+	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	if (Z_TYPE_P(val) == IS_TRUE) {			
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val TSRMLS_CC));
+		FREE_OP1();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index b95cd8d6d6..e5657e726a 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2345,13 +2345,20 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *val;
 
 
 	SAVE_OPLINE();
-	boolean_not_function(EX_VAR(opline->result.var),
-		opline->op1.zv TSRMLS_CC);
+	val = opline->op1.zv;
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val TSRMLS_CC));
 
-	CHECK_EXCEPTION();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -2400,11 +2407,13 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CONST == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -2431,11 +2440,13 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CONST == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -2462,11 +2473,13 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR) {
-		if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
-			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CONST == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -2493,13 +2506,15 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (IS_CONST == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -2529,13 +2544,15 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (IS_CONST == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -2717,14 +2734,20 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *val;
 
-	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv TSRMLS_CC));
+	val = opline->op1.zv;
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val TSRMLS_CC));
 
-	CHECK_EXCEPTION();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -5176,60 +5199,6 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op2;
-	zval *function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-	zend_fcall_info_cache fcc;
-	char *error = NULL;
-	zend_function *func;
-	zend_class_entry *called_scope;
-	zend_object *object;
-
-	if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error TSRMLS_CC)) {
-		if (error) {
-			efree(error);
-		}
-		func = fcc.function_handler;
-		if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
-			/* Delay closure destruction until its invocation */
-			func->common.prototype = (zend_function*)Z_OBJ_P(function_name);
-			Z_ADDREF_P(function_name);
-		}
-		called_scope = fcc.called_scope;
-		object = fcc.object;
-		if (object) {
-			GC_REFCOUNT(object)++; /* For $this pointer */
-		} else if (func->common.scope &&
-		           !(func->common.fn_flags & ZEND_ACC_STATIC)) {
-			if (func->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_STRICT,
-				"Non-static method %s::%s() should not be called statically",
-				func->common.scope->name->val, func->common.function_name->val);
-			} else {
-				zend_error_noreturn(
-					E_ERROR,
-					"Non-static method %s::%s() cannot be called statically",
-					func->common.scope->name->val, func->common.function_name->val);
-			}
-		}
-	} else {
-		zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error);
-		efree(error);
-		func = (zend_function*)&zend_pass_function;
-		called_scope = NULL;
-		object = NULL;
-	}
-
-	EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-		func, opline->extended_value, called_scope, object, EX(call) TSRMLS_CC);
-
-	zval_ptr_dtor_nogc(free_op2);
-	CHECK_EXCEPTION();
-	ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -5675,60 +5644,6 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 	return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op2;
-	zval *function_name = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
-	zend_fcall_info_cache fcc;
-	char *error = NULL;
-	zend_function *func;
-	zend_class_entry *called_scope;
-	zend_object *object;
-
-	if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error TSRMLS_CC)) {
-		if (error) {
-			efree(error);
-		}
-		func = fcc.function_handler;
-		if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
-			/* Delay closure destruction until its invocation */
-			func->common.prototype = (zend_function*)Z_OBJ_P(function_name);
-			Z_ADDREF_P(function_name);
-		}
-		called_scope = fcc.called_scope;
-		object = fcc.object;
-		if (object) {
-			GC_REFCOUNT(object)++; /* For $this pointer */
-		} else if (func->common.scope &&
-		           !(func->common.fn_flags & ZEND_ACC_STATIC)) {
-			if (func->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_STRICT,
-				"Non-static method %s::%s() should not be called statically",
-				func->common.scope->name->val, func->common.function_name->val);
-			} else {
-				zend_error_noreturn(
-					E_ERROR,
-					"Non-static method %s::%s() cannot be called statically",
-					func->common.scope->name->val, func->common.function_name->val);
-			}
-		}
-	} else {
-		zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error);
-		efree(error);
-		func = (zend_function*)&zend_pass_function;
-		called_scope = NULL;
-		object = NULL;
-	}
-
-	EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
-		func, opline->extended_value, called_scope, object, EX(call) TSRMLS_CC);
-
-	zval_ptr_dtor_nogc(free_op2);
-	CHECK_EXCEPTION();
-	ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -7359,7 +7274,7 @@ static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 
-	zval *function_name = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	zval *function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 	zend_fcall_info_cache fcc;
 	char *error = NULL;
 	zend_function *func;
@@ -8340,6 +8255,60 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+	zend_fcall_info_cache fcc;
+	char *error = NULL;
+	zend_function *func;
+	zend_class_entry *called_scope;
+	zend_object *object;
+
+	if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error TSRMLS_CC)) {
+		if (error) {
+			efree(error);
+		}
+		func = fcc.function_handler;
+		if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
+			/* Delay closure destruction until its invocation */
+			func->common.prototype = (zend_function*)Z_OBJ_P(function_name);
+			Z_ADDREF_P(function_name);
+		}
+		called_scope = fcc.called_scope;
+		object = fcc.object;
+		if (object) {
+			GC_REFCOUNT(object)++; /* For $this pointer */
+		} else if (func->common.scope &&
+		           !(func->common.fn_flags & ZEND_ACC_STATIC)) {
+			if (func->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
+				zend_error(E_STRICT,
+				"Non-static method %s::%s() should not be called statically",
+				func->common.scope->name->val, func->common.function_name->val);
+			} else {
+				zend_error_noreturn(
+					E_ERROR,
+					"Non-static method %s::%s() cannot be called statically",
+					func->common.scope->name->val, func->common.function_name->val);
+			}
+		}
+	} else {
+		zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error);
+		efree(error);
+		func = (zend_function*)&zend_pass_function;
+		called_scope = NULL;
+		object = NULL;
+	}
+
+	EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
+		func, opline->extended_value, called_scope, object, EX(call) TSRMLS_CC);
+
+	zval_ptr_dtor_nogc(free_op2);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -8635,182 +8604,6 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-
-	SAVE_OPLINE();
-	boolean_not_function(EX_VAR(opline->result.var),
-		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1) TSRMLS_CC);
-	zval_ptr_dtor_nogc(free_op1);
-	CHECK_EXCEPTION();
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_TMP_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline++;
-	} else {
-		opline = opline->op2.jmp_addr;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_TMP_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline = opline->op2.jmp_addr;
-	} else {
-		opline++;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_TMP_VAR == IS_TMP_VAR) {
-		if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
-			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline = (zend_op*)(((char*)opline) + opline->extended_value);
-	} else {
-		opline = opline->op2.jmp_addr;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_TMP_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		zval_ptr_dtor_nogc(free_op1);
-		ZVAL_TRUE(EX_VAR(opline->result.var));
-		opline++;
-	} else {
-		zval_ptr_dtor_nogc(free_op1);
-		ZVAL_FALSE(EX_VAR(opline->result.var));
-		opline = opline->op2.jmp_addr;
-	}
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_TMP_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		}
-	}
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		ZVAL_TRUE(EX_VAR(opline->result.var));
-		opline = opline->op2.jmp_addr;
-	} else {
-		ZVAL_FALSE(EX_VAR(opline->result.var));
-		opline++;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -12983,19 +12776,6 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-
-	SAVE_OPLINE();
-	boolean_not_function(EX_VAR(opline->result.var),
-		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1) TSRMLS_CC);
-	zval_ptr_dtor_nogc(free_op1);
-	CHECK_EXCEPTION();
-	ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -13154,169 +12934,6 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline++;
-	} else {
-		opline = opline->op2.jmp_addr;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline = opline->op2.jmp_addr;
-	} else {
-		opline++;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_VAR == IS_TMP_VAR) {
-		if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
-			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		opline = (zend_op*)(((char*)opline) + opline->extended_value);
-	} else {
-		opline = opline->op2.jmp_addr;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		}
-	}
-
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		zval_ptr_dtor_nogc(free_op1);
-		ZVAL_TRUE(EX_VAR(opline->result.var));
-		opline++;
-	} else {
-		zval_ptr_dtor_nogc(free_op1);
-		ZVAL_FALSE(EX_VAR(opline->result.var));
-		opline = opline->op2.jmp_addr;
-	}
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
-static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zend_free_op free_op1;
-	zval *val;
-
-	SAVE_OPLINE();
-	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
-
-	if (IS_VAR == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		}
-	}
-	if (i_zend_is_true(val TSRMLS_CC)) {
-		ZVAL_TRUE(EX_VAR(opline->result.var));
-		opline = opline->op2.jmp_addr;
-	} else {
-		ZVAL_FALSE(EX_VAR(opline->result.var));
-		opline++;
-	}
-	zval_ptr_dtor_nogc(free_op1);
-	if (UNEXPECTED(EG(exception) != NULL)) {
-		HANDLE_EXCEPTION();
-	}
-	ZEND_VM_JMP(opline);
-}
-
 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -17480,7 +17097,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(int (*bin
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+		zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_VAR TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -19116,7 +18733,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CV(int (*bina
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -24078,7 +23695,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(int (*
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+		zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_VAR TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -25033,7 +24650,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(int (*b
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -27097,13 +26714,20 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *val;
 
 
 	SAVE_OPLINE();
-	boolean_not_function(EX_VAR(opline->result.var),
-		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val TSRMLS_CC));
 
-	CHECK_EXCEPTION();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -27304,13 +26928,15 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *val;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CV == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -27335,13 +26961,15 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *val;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CV == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -27366,13 +26994,15 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *val;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR) {
-		if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
-			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+	if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if (IS_CV == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -27397,15 +27027,17 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *val;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline + 1);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (IS_CV == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
 			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
 			ZEND_VM_CONTINUE();
 		}
@@ -27433,15 +27065,17 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zval *val;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR) {
-		if (Z_TYPE_P(val) == IS_TRUE) {
-			ZVAL_TRUE(EX_VAR(opline->result.var));
-			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
-			ZEND_VM_CONTINUE();
-		} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
-			ZVAL_FALSE(EX_VAR(opline->result.var));
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if (IS_CV == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
 			ZEND_VM_SET_OPCODE(opline + 1);
 			ZEND_VM_CONTINUE();
 		}
@@ -27778,14 +27412,20 @@ static int ZEND_FASTCALL  ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *val;
 
-	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC));
+	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val TSRMLS_CC));
 
-	CHECK_EXCEPTION();
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -31701,7 +31341,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_VAR(int (*bina
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
+		zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_VAR TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -33902,7 +33542,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CV(int (*binar
 		}
 		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else {
-		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV TSRMLS_CC);
 		value = get_zval_ptr_deref((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
@@ -36704,6 +36344,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEN
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *val;
+	zend_free_op free_op1;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val TSRMLS_CC));
+		zval_ptr_dtor_nogc(free_op1);
+		CHECK_EXCEPTION();
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -36741,6 +36401,179 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	return ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *val;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
+			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+			ZEND_VM_CONTINUE();
+		}
+	}
+
+	if (i_zend_is_true(val TSRMLS_CC)) {
+		opline++;
+	} else {
+		opline = opline->op2.jmp_addr;
+	}
+	zval_ptr_dtor_nogc(free_op1);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		HANDLE_EXCEPTION();
+	}
+	ZEND_VM_JMP(opline);
+}
+
+static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *val;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			ZEND_VM_SET_OPCODE(opline + 1);
+			ZEND_VM_CONTINUE();
+		}
+	}
+
+	if (i_zend_is_true(val TSRMLS_CC)) {
+		opline = opline->op2.jmp_addr;
+	} else {
+		opline++;
+	}
+	zval_ptr_dtor_nogc(free_op1);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		HANDLE_EXCEPTION();
+	}
+	ZEND_VM_JMP(opline);
+}
+
+static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *val;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+	if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) {
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
+			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+			ZEND_VM_CONTINUE();
+		}
+	}
+
+	if (i_zend_is_true(val TSRMLS_CC)) {
+		opline = (zend_op*)(((char*)opline) + opline->extended_value);
+	} else {
+		opline = opline->op2.jmp_addr;
+	}
+	zval_ptr_dtor_nogc(free_op1);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		HANDLE_EXCEPTION();
+	}
+	ZEND_VM_JMP(opline);
+}
+
+static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *val;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline + 1);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
+			ZEND_VM_JMP(opline->op2.jmp_addr);
+		} else {
+			ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+			ZEND_VM_CONTINUE();
+		}
+	}
+
+	if (i_zend_is_true(val TSRMLS_CC)) {
+		zval_ptr_dtor_nogc(free_op1);
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		opline++;
+	} else {
+		zval_ptr_dtor_nogc(free_op1);
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		opline = opline->op2.jmp_addr;
+	}
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		HANDLE_EXCEPTION();
+	}
+	ZEND_VM_JMP(opline);
+}
+
+static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *val;
+
+	SAVE_OPLINE();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
+		ZEND_VM_CONTINUE();
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
+			ZEND_VM_NEXT_OPCODE();
+		} else {
+			ZEND_VM_SET_OPCODE(opline + 1);
+			ZEND_VM_CONTINUE();
+		}
+	}
+	if (i_zend_is_true(val TSRMLS_CC)) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+		opline = opline->op2.jmp_addr;
+	} else {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+		opline++;
+	}
+	zval_ptr_dtor_nogc(free_op1);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		HANDLE_EXCEPTION();
+	}
+	ZEND_VM_JMP(opline);
+}
+
 static int ZEND_FASTCALL  ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -36754,15 +36587,20 @@ static int ZEND_FASTCALL  ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *val;
 	zend_free_op free_op1;
-	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1) TSRMLS_CC));
-	zval_ptr_dtor_nogc(free_op1);
-
-	CHECK_EXCEPTION();
+	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+	if (Z_TYPE_P(val) == IS_TRUE) {
+		ZVAL_TRUE(EX_VAR(opline->result.var));
+	} else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	} else {
+		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val TSRMLS_CC));
+		zval_ptr_dtor_nogc(free_op1);
+		CHECK_EXCEPTION();
+	}
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -38535,16 +38373,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
   	ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
   	ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
-  	ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
+  	ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -39285,16 +39123,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_JMPZ_SPEC_CONST_HANDLER,
   	ZEND_JMPZ_SPEC_CONST_HANDLER,
   	ZEND_JMPZ_SPEC_CONST_HANDLER,
-  	ZEND_JMPZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_SPEC_VAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -39310,16 +39148,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_JMPNZ_SPEC_CONST_HANDLER,
   	ZEND_JMPNZ_SPEC_CONST_HANDLER,
   	ZEND_JMPNZ_SPEC_CONST_HANDLER,
-  	ZEND_JMPNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_SPEC_VAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -39335,16 +39173,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_JMPZNZ_SPEC_CONST_HANDLER,
   	ZEND_JMPZNZ_SPEC_CONST_HANDLER,
   	ZEND_JMPZNZ_SPEC_CONST_HANDLER,
-  	ZEND_JMPZNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZNZ_SPEC_TMP_HANDLER,
-  	ZEND_JMPZNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZNZ_SPEC_VAR_HANDLER,
-  	ZEND_JMPZNZ_SPEC_VAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -39360,16 +39198,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
   	ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
   	ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -39385,16 +39223,16 @@ void zend_init_opcodes_handlers(void)
   	ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
   	ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
   	ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
-  	ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
+  	ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
@@ -41156,8 +40994,8 @@ void zend_init_opcodes_handlers(void)
   	ZEND_SEND_VAR_SPEC_CV_HANDLER,
   	ZEND_SEND_VAR_SPEC_CV_HANDLER,
   	ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
-  	ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER,
-  	ZEND_INIT_USER_CALL_SPEC_CONST_VAR_HANDLER,
+  	ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
+  	ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
   	ZEND_NULL_HANDLER,