Add fast paths for bitwise operators

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index c64eebb7816ab249f7cb65fa37d95916c888d6a7..2d2cd1b15891d31ec702ecd8d1d6780c52813e4a 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -216,9 +216,22 @@ ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
+       op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
+       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
        FREE_OP1();
        FREE_OP2();
@@ -231,9 +244,22 @@ ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
+       op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
+       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
        FREE_OP1();
        FREE_OP2();
@@ -608,9 +634,21 @@ ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
+       op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
+       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
        FREE_OP1();
        FREE_OP2();
@@ -623,9 +661,21 @@ ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
+       op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
+       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
        FREE_OP1();
        FREE_OP2();
@@ -638,9 +688,21 @@ ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
+       op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
+       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
        FREE_OP1();
        FREE_OP2();

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 15acbd29fbd866ade9d5b302dd6a459b1fbef152..a8cb17e3b8408f5590ed09db473877ce4c4726ca 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4276,9 +4276,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -4291,9 +4304,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -4668,9 +4694,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -4683,9 +4721,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -4698,9 +4748,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8248,9 +8310,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8263,9 +8338,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8640,9 +8728,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8655,9 +8755,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(Z
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -8670,9 +8782,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(Z
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -10178,9 +10302,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVAR_HANDLER(Z
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10193,9 +10330,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVAR_HANDLER(Z
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10534,9 +10684,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMPVAR_HANDLE
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10549,9 +10711,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMPVAR_HANDL
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -10564,9 +10738,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMPVAR_HANDL
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = EX_CONSTANT(opline->op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -36056,9 +36242,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -36071,9 +36270,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -36448,9 +36660,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZE
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -36463,9 +36687,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(Z
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -36478,9 +36714,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(Z
 
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -43050,9 +43298,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPC
 
        zval *op1, *op2;
 
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -43065,9 +43326,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPC
 
        zval *op1, *op2;
 
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -43442,9 +43716,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_
 
        zval *op1, *op2;
 
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -43457,9 +43743,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND
 
        zval *op1, *op2;
 
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -43472,9 +43770,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND
 
        zval *op1, *op2;
 
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
        SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
 
@@ -47084,9 +47394,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CV_TMPVAR_HANDLER(ZEND
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -47099,9 +47422,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CV_TMPVAR_HANDLER(ZEND
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -47440,9 +47776,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMPVAR_HANDLER(Z
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -47455,9 +47803,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMPVAR_HANDLER(
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -47470,9 +47830,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMPVAR_HANDLER(
        zend_free_op free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
-       op1 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+       op1 = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
 
        zval_ptr_dtor_nogc(free_op2);
@@ -51383,9 +51755,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_CONST_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51398,9 +51783,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_CONST_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51739,9 +52137,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_CONST_HANDLE
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51754,9 +52164,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_CONST_HANDL
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -51769,9 +52191,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_CONST_HANDL
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = EX_CONSTANT(opline->op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -53867,9 +54301,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_CV_HANDLER(ZEND
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -53882,9 +54329,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_CV_HANDLER(ZEND
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -54223,9 +54683,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_CV_HANDLER(Z
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -54238,9 +54710,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_CV_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -54253,9 +54737,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_CV_HANDLER(
        zend_free_op free_op1;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       op2 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+       op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
 
@@ -55085,9 +55581,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_TMPVAR_HANDLER(
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) << Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_left_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -55100,9 +55609,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_TMPVAR_HANDLER(
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
+                       && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        shift_right_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -55441,9 +55963,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_TMPVAR_HANDL
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_or_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -55456,9 +55990,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_TMPVAR_HAND
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_and_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);
@@ -55471,9 +56017,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_TMPVAR_HAND
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
 
-       SAVE_OPLINE();
        op1 = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
        op2 = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
+                       && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
+               op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);
+       }
+       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
+               op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);
+       }
        bitwise_xor_function(EX_VAR(opline->result.var), op1, op2);
        zval_ptr_dtor_nogc(free_op1);
        zval_ptr_dtor_nogc(free_op2);