Use IS_EQUAL instead of CASE when first operand is CV or CONST. Removed CASE handlers...

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index a032188e11fc2e7ca7ec8f244fc246190f8c17c9..ff69e2ebb4aabb6c3eb118e31cec305b4d7038ca 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -5021,8 +5021,10 @@ void zend_compile_switch(zend_ast *ast) /* {{{ */
                } else if (expr_node.op_type == IS_CONST
                        && Z_TYPE(expr_node.u.constant) == IS_TRUE) {
                        jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, 0);
-               } else {                    
-                       opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node);
+               } else {
+                       opline = zend_emit_op(NULL,
+                               (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) ? ZEND_CASE : ZEND_IS_EQUAL,
+                               &expr_node, &cond_node);
                        SET_NODE(opline->result, &case_node);
                        if (opline->op1_type == IS_CONST) {
                                zval_copy_ctor(CT_CONSTANT(opline->op1));

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index ec0ac3808397543521b8ef26f99be9e566d7491a..171c009c593f3030ba2e18b5badbbd2dbb3f7df5 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4785,7 +4785,7 @@ ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index de87cde904e44754d19e9b0cdcda1c4744429a08..312e9e99e8cc7895278a62197f06988ae9c45aae 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -5694,62 +5694,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2, *result;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_class_entry *ce, *scope;
@@ -7962,62 +7906,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2, *result;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-                               zval_ptr_dtor_nogc(free_op2);
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-       zval_ptr_dtor_nogc(free_op2);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11209,62 +11097,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZE
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2, *result;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -42793,62 +42625,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2, *result;
-
-       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -46683,62 +46459,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2, *result;
-
-       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-                               zval_ptr_dtor_nogc(free_op2);
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-       zval_ptr_dtor_nogc(free_op2);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -52578,62 +52298,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2, *result;
-
-       op1 = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-       op2 = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
-       do {
-               int result;
-
-               if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                               result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-                       } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                               result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-                       } else {
-                               break;
-                       }
-               } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
-                       if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                               result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
-
-                       } else {
-                               break;
-                       }
-               } else {
-                       break;
-               }
-               ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
-       } while (0);
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
-       }
-       result = EX_VAR(opline->result.var);
-       compare_function(result, op1, op2);
-       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -54700,11 +54364,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CONST_TMPVAR_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CONST_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CONST_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
                        (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
@@ -54720,11 +54384,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_CASE_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -58601,9 +58265,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
                                ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CONST_CONST):
-                               ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
                                ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -58754,9 +58415,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
                                ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CONST_TMPVAR):
-                               ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
                                ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -58952,9 +58610,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_CATCH_SPEC_CONST_CV):
                                ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CONST_CV):
-                               ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
                                ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -61322,9 +60977,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
                                ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CV_CONST):
-                               ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
                                ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -61610,9 +61262,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
                                ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CV_TMPVAR):
-                               ZEND_CASE_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
                                ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -62093,9 +61742,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
                                ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_CASE_SPEC_CV_CV):
-                               ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
                                ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -63610,11 +63256,11 @@ void zend_init_opcodes_handlers(void)
                ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
-               ZEND_CASE_SPEC_CONST_CONST_HANDLER,
-               ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER,
-               ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_CASE_SPEC_CONST_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
                ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
                ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
@@ -63630,11 +63276,11 @@ void zend_init_opcodes_handlers(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_CASE_SPEC_CV_CONST_HANDLER,
-               ZEND_CASE_SPEC_CV_TMPVAR_HANDLER,
-               ZEND_CASE_SPEC_CV_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_CASE_SPEC_CV_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index c0040c83bba0646af4ff80fe536c33adf8d24463..38cd265d42689a7dab8fa675b9e05a924697272a 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -272,7 +272,7 @@ static uint32_t zend_vm_opcodes_flags[199] = {
        0x03002007,
        0x00002007,
        0x00002007,
-       0x00000707,
+       0x00000705,
        0x00000101,
        0x00001001,
        0x00000101,

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index aa1550f5fbe01315c17f971af0042cacec0dbdfc..d6a6ffde538ae4dabf8fa6419dab23f02b606234 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -287,8 +287,10 @@ static zend_bool try_replace_op1(
                } else {
                        // TODO: check the following special cases ???
                        switch (opline->opcode) {
-                               case ZEND_FETCH_LIST_R:
                                case ZEND_CASE:
+                                       opline->opcode = ZEND_IS_EQUAL;
+                                       /* break missing intentionally */
+                               case ZEND_FETCH_LIST_R:
                                case ZEND_SWITCH_STRING:
                                case ZEND_SWITCH_LONG:
                                        if (Z_TYPE(zv) == IS_STRING) {

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index f63c2c038391e0385e04fe043689bbd12ee53554..bd859eaee6159de40380be3d052b54ba7e0d4f3f 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -663,6 +663,10 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array,
                                                                        || m->opcode == ZEND_SWITCH_LONG
                                                                        || m->opcode == ZEND_SWITCH_STRING) {
                                                                zval v;
+
+                                                               if (m->opcode == ZEND_CASE) {
+                                                                       m->opcode = ZEND_IS_EQUAL;
+                                                               }
                                                                ZVAL_COPY_VALUE(&v, val);
                                                                zval_copy_ctor(&v);
                                                                if (Z_TYPE(v) == IS_STRING) {