Skip to content

Instantly share code, notes, and snippets.

@dstogov

dstogov/smart_branch-16.diff

Last active October 8, 2019 10:39
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save dstogov/6b664e558acb42179ca9d8b850db8dd5 to your computer and use it in GitHub Desktop.
Save dstogov/6b664e558acb42179ca9d8b850db8dd5 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
smart_branch-16.diff
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 2d5fd66efd..3c9b0f834b 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2000,22 +2000,31 @@ ZEND_API int zend_is_smart_branch(zend_op *opline) /* {{{ */
static inline uint32_t zend_emit_cond_jump(zend_uchar opcode, znode *cond, uint32_t opnum_target) /* {{{ */
{
uint32_t opnum = get_next_op_number();
- zend_op *opline;
+ zend_op *opline = CG(active_op_array)->opcodes + opnum -1;
- if ((cond->op_type & (IS_CV|IS_CONST))
+ if ((cond->op_type == IS_TMP_VAR)
&& opnum > 0
- && zend_is_smart_branch(CG(active_op_array)->opcodes + opnum - 1)) {
- /* emit extra NOP to avoid incorrect SMART_BRANCH in very rare cases */
- zend_emit_op(NULL, ZEND_NOP, NULL, NULL);
- opnum = get_next_op_number();
+ && zend_is_smart_branch(opline)
+ && opline->result_type == IS_TMP_VAR
+ && opline->result.var == cond->u.op.var) {
+ /* Use result of SMART_BRANCH instruction as jump target */
+ if (opcode == ZEND_JMPZ) {
+ opline->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPZ;
+ } else {
+ ZEND_ASSERT(opcode == ZEND_JMPNZ);
+ opline->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPNZ;
+ }
+ opline->result.opline_num = opnum_target;
+ return opnum - 1;
+ } else {
+ opline = zend_emit_op(NULL, opcode, cond, NULL);
+ opline->op2.opline_num = opnum_target;
+ return opnum;
}
- opline = zend_emit_op(NULL, opcode, cond, NULL);
- opline->op2.opline_num = opnum_target;
- return opnum;
}
/* }}} */
-static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target) /* {{{ */
+static void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target) /* {{{ */
{
zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump];
switch (opline->opcode) {
@@ -2030,6 +2039,25 @@ static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_t
case ZEND_COALESCE:
opline->op2.opline_num = opnum_target;
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ opline->result.opline_num = opnum_target;
+ break;
EMPTY_SWITCH_DEFAULT_CASE()
}
}
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 9a314ccbdc..b34f991c89 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -702,6 +702,10 @@ struct _zend_execute_data {
#define IS_VAR (1<<2)
#define IS_CV (1<<3) /* Compiled variable */
+/* Used for result.type of smart branch instructions */
+#define IS_SMART_BRANCH_JMPZ (1<<4)
+#define IS_SMART_BRANCH_JMPNZ (1<<5)
+
#define ZEND_EXTRA_VALUE 1
#include "zend_globals.h"
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 5aaf415adf..0cf47ca27a 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -4245,103 +4245,107 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
OPLINE++
-#ifndef VM_SMART_OPCODES
-# define VM_SMART_OPCODES 1
-#endif
-
-#if VM_SMART_OPCODES
-# define ZEND_VM_REPEATABLE_OPCODE \
+#define ZEND_VM_REPEATABLE_OPCODE \
do {
-# define ZEND_VM_REPEAT_OPCODE(_opcode) \
+#define ZEND_VM_REPEAT_OPCODE(_opcode) \
} while (UNEXPECTED((++opline)->opcode == _opcode)); \
OPLINE = opline; \
ZEND_VM_CONTINUE()
-# define ZEND_VM_SMART_BRANCH(_result, _check) do { \
- if ((_check) && UNEXPECTED(EG(exception))) { \
- break; \
- } \
- if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
+#define ZEND_VM_SMART_BRANCH(_result, _check) do { \
+ if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPZ)) { \
if (_result) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
} else { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
} \
- } else if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
+ } else if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPNZ)) { \
if (!(_result)) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
} else { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
} \
} else { \
- break; \
+ ZVAL_BOOL(EX_VAR(opline->result.var), _result); \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
+ } \
+ if ((_check) && UNEXPECTED(EG(exception))) { \
+ OPLINE = EX(opline); \
} \
ZEND_VM_CONTINUE(); \
} while (0)
-# define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \
+#define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \
if ((_check) && UNEXPECTED(EG(exception))) { \
- break; \
- } \
- if (_result) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ OPLINE = EX(opline); \
+ } else if (_result) { \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
} else { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
} \
ZEND_VM_CONTINUE(); \
} while (0)
-# define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check) do { \
+#define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check) do { \
if ((_check) && UNEXPECTED(EG(exception))) { \
- break; \
- } \
- if (!(_result)) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ OPLINE = EX(opline); \
+ } else if (!(_result)) { \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
} else { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
} \
ZEND_VM_CONTINUE(); \
} while (0)
+#define ZEND_VM_SMART_BRANCH_NONE(_result, _check) do { \
+ ZVAL_BOOL(EX_VAR(opline->result.var), _result); \
+ ZEND_VM_NEXT_OPCODE_EX(_check, 1); \
+ ZEND_VM_CONTINUE(); \
+ } while (0)
#define ZEND_VM_SMART_BRANCH_TRUE() do { \
- if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPNZ)) { \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
ZEND_VM_CONTINUE(); \
- } else if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ } else if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPZ)) { \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
ZEND_VM_CONTINUE(); \
+ } else { \
+ ZVAL_TRUE(EX_VAR(opline->result.var)); \
+ ZEND_VM_NEXT_OPCODE(); \
} \
} while (0)
#define ZEND_VM_SMART_BRANCH_TRUE_JMPZ() do { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
ZEND_VM_CONTINUE(); \
} while (0)
#define ZEND_VM_SMART_BRANCH_TRUE_JMPNZ() do { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
ZEND_VM_CONTINUE(); \
} while (0)
+#define ZEND_VM_SMART_BRANCH_TRUE_NONE() do { \
+ ZVAL_TRUE(EX_VAR(opline->result.var)); \
+ ZEND_VM_NEXT_OPCODE(); \
+ } while (0)
#define ZEND_VM_SMART_BRANCH_FALSE() do { \
- if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPNZ)) { \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
ZEND_VM_CONTINUE(); \
- } else if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ } else if (EXPECTED(opline->result_type == IS_SMART_BRANCH_JMPZ)) { \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
ZEND_VM_CONTINUE(); \
+ } else { \
+ ZVAL_FALSE(EX_VAR(opline->result.var)); \
+ ZEND_VM_NEXT_OPCODE(); \
} \
} while (0)
#define ZEND_VM_SMART_BRANCH_FALSE_JMPZ() do { \
- ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->result)); \
ZEND_VM_CONTINUE(); \
} while (0)
#define ZEND_VM_SMART_BRANCH_FALSE_JMPNZ() do { \
- ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+ ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
ZEND_VM_CONTINUE(); \
} while (0)
-#else
-# define ZEND_VM_REPEATABLE_OPCODE
-# define ZEND_VM_REPEAT_OPCODE(_opcode)
-# define ZEND_VM_SMART_BRANCH(_result, _check)
-# define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check)
-# define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check)
-# define ZEND_VM_SMART_BRANCH_TRUE()
-# define ZEND_VM_SMART_BRANCH_FALSE()
-#endif
+#define ZEND_VM_SMART_BRANCH_FALSE_NONE() do { \
+ ZVAL_FALSE(EX_VAR(opline->result.var)); \
+ ZEND_VM_NEXT_OPCODE(); \
+ } while (0)
#ifdef __GNUC__
# define ZEND_VM_GUARD(name) __asm__("#" #name)
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 54886a3d07..b9697b74b5 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -991,6 +991,27 @@ ZEND_API int pass_two(zend_op_array *op_array)
opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->result);
+ }
+ break;
}
if (opline->op1_type == IS_CONST) {
ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1);
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 9680f4553a..608e5bbaae 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -455,8 +455,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|T
FREE_OP1();
FREE_OP2();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
@@ -472,8 +470,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON
FREE_OP1();
FREE_OP2();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
@@ -495,19 +491,7 @@ ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret == 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret == 0, 1);
}
ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
@@ -525,13 +509,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
ZEND_VM_C_LABEL(is_equal_true):
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_C_LABEL(is_equal_false):
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -591,19 +571,7 @@ ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret != 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret != 0, 1);
}
ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
@@ -621,13 +589,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TM
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
ZEND_VM_C_LABEL(is_not_equal_true):
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_C_LABEL(is_not_equal_false):
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -687,19 +651,7 @@ ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2)
if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret < 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret < 0, 1);
}
ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
@@ -717,13 +669,9 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPV
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
ZEND_VM_C_LABEL(is_smaller_true):
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_C_LABEL(is_smaller_false):
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -768,19 +716,7 @@ ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2
if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret <= 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret <= 0, 1);
}
ZEND_VM_HOT_NOCONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
@@ -5274,19 +5210,7 @@ ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2)
if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret == 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret == 0, 1);
}
ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
@@ -5302,13 +5226,9 @@ ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
ZEND_VM_C_LABEL(case_true):
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_C_LABEL(case_false):
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -6703,25 +6623,15 @@ ZEND_VM_HOT_HANDLER(154, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET, SPEC(ISSET))
if (Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else {
int result;
SAVE_OPLINE();
result = !i_zend_is_true(value);
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH(result, 1);
}
}
@@ -6767,8 +6677,6 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -6790,8 +6698,6 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CAC
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_COLD_CONSTCONST_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|CV, CONST|TMPVAR|CV, ISSET)
@@ -6846,8 +6752,6 @@ ZEND_VM_C_LABEL(num_index_prop):
/* avoid exception check */
FREE_OP2();
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -6873,8 +6777,6 @@ ZEND_VM_C_LABEL(isset_dim_obj_exit):
FREE_OP2();
FREE_OP1();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET|CACHE_SLOT)
@@ -6930,8 +6832,6 @@ ZEND_VM_C_LABEL(isset_object_finish):
FREE_OP2();
FREE_OP1();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HANDLER(194, ZEND_ARRAY_KEY_EXISTS, CV|TMPVAR|CONST, CV|TMPVAR|CONST)
@@ -6964,8 +6864,6 @@ ZEND_VM_C_LABEL(array_key_exists_array):
FREE_OP2();
FREE_OP1();
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -7334,8 +7232,6 @@ ZEND_VM_C_LABEL(try_instanceof):
}
FREE_OP1();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HOT_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
@@ -8052,12 +7948,8 @@ ZEND_VM_C_LABEL(type_check_resource):
SAVE_OPLINE();
FREE_OP1();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
}
@@ -8071,13 +7963,9 @@ ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
if (!IS_SPECIAL_CACHE_VAL(c)) {
ZEND_VM_C_LABEL(defined_true):
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
ZEND_VM_C_LABEL(defined_false):
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
}
if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
@@ -8521,8 +8409,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM
}
FREE_OP1();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_COLD_CONST_HANDLER(190, ZEND_COUNT, CONST|TMPVAR|CV, UNUSED)
@@ -8879,8 +8765,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_LONG && op2_inf
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8893,8 +8777,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_i
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_NOT_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8907,8 +8789,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_LONG && op2
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_NOT_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8921,8 +8801,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_DOUBLE && o
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8935,8 +8813,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_LONG && op2_i
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8949,8 +8825,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_DOUBLE && op2
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_OR_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8963,8 +8837,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_LONG
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_OR_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8977,8 +8849,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUB
op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 07bc67cfd6..30104d7e2c 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -595,19 +595,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_hel
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret == 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret == 0, 1);
}
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -629,19 +617,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret != 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret != 0, 1);
}
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -663,19 +639,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_h
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret < 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret < 0, 1);
}
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -697,19 +661,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_o
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret <= 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret <= 0, 1);
}
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -2123,19 +2075,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
zval_ptr_dtor_nogc(op_2);
}
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- if (ret == 0) {
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
+ ZEND_VM_SMART_BRANCH(ret == 0, 1);
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -2316,8 +2256,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4525,12 +4463,8 @@ type_check_resource:
SAVE_OPLINE();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
}
@@ -4544,13 +4478,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST
if (!IS_SPECIAL_CACHE_VAL(c)) {
defined_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
defined_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
}
if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
@@ -4842,8 +4772,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4859,8 +4787,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4878,13 +4804,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -4940,13 +4862,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -5002,13 +4920,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -6201,8 +6115,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -6228,8 +6140,6 @@ isset_dim_obj_exit:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6285,8 +6195,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6318,8 +6226,6 @@ array_key_exists_array:
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -6614,8 +6520,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6775,14 +6679,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_smaller_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -6823,13 +6723,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -6870,13 +6766,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -6916,12 +6808,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
is_smaller_or_equal_true:
-
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
ZVAL_TRUE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_or_equal_false:
-
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
ZVAL_FALSE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
}
@@ -7088,9 +6980,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMP
op1 = RT_CONSTANT(opline, opline->op1);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7103,8 +6993,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7117,8 +7005,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7130,9 +7016,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_T
op1 = RT_CONSTANT(opline, opline->op1);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7145,8 +7029,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7159,8 +7041,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7172,9 +7052,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
op1 = RT_CONSTANT(opline, opline->op1);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7187,8 +7065,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7201,8 +7077,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7214,9 +7088,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
op1 = RT_CONSTANT(opline, opline->op1);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7229,8 +7101,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7243,8 +7113,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8380,8 +8248,6 @@ num_index_prop:
/* avoid exception check */
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -8407,8 +8273,6 @@ isset_dim_obj_exit:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8464,8 +8328,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8498,8 +8360,6 @@ array_key_exists_array:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -9368,8 +9228,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -10815,8 +10673,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -10842,8 +10698,6 @@ isset_dim_obj_exit:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10899,8 +10753,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10932,8 +10784,6 @@ array_key_exists_array:
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -11302,14 +11152,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_smaller_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -11350,13 +11196,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -11397,13 +11239,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -11443,12 +11281,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
is_smaller_or_equal_true:
-
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
ZVAL_TRUE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_or_equal_false:
-
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
ZVAL_FALSE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
}
@@ -11816,9 +11654,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CO
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11831,8 +11667,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11845,8 +11679,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11858,9 +11690,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11873,8 +11703,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11887,8 +11715,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11900,9 +11726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARC
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11915,8 +11739,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11929,8 +11751,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11942,9 +11762,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVA
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11957,8 +11775,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11971,8 +11787,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11984,9 +11798,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11999,8 +11811,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12013,8 +11823,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12026,9 +11834,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARC
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12041,8 +11847,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12055,8 +11859,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12068,9 +11870,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12083,8 +11883,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12097,8 +11895,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12110,9 +11906,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
op1 = EX_VAR(opline->op1.var);
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12125,8 +11919,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12139,8 +11931,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = RT_CONSTANT(opline, opline->op2);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12341,14 +12131,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVA
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_smaller_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -12389,13 +12175,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -12436,13 +12218,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
is_smaller_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -12482,12 +12260,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
is_smaller_or_equal_true:
-
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
ZVAL_TRUE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
} else {
is_smaller_or_equal_false:
-
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
ZVAL_FALSE(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE();
}
@@ -12782,9 +12560,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TM
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12797,8 +12573,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12811,8 +12585,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12824,9 +12596,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12839,8 +12609,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12853,8 +12621,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12866,9 +12632,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARC
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12881,8 +12645,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12895,8 +12657,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12908,9 +12668,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVA
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12923,8 +12681,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12937,8 +12693,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12950,9 +12704,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12965,8 +12717,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12979,8 +12729,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12992,9 +12740,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARC
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13007,8 +12753,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13021,8 +12765,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13034,9 +12776,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13049,8 +12789,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13063,8 +12801,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13076,9 +12812,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
op1 = EX_VAR(opline->op1.var);
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_NONE(result, 0);
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13091,8 +12825,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13105,8 +12837,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
op2 = EX_VAR(opline->op2.var);
result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13657,12 +13387,8 @@ type_check_resource:
SAVE_OPLINE();
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
}
@@ -13779,14 +13505,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -13842,13 +13564,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -13904,13 +13622,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -13965,14 +13679,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_not_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -14028,13 +13738,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -14090,13 +13796,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -14735,13 +14437,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
case_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
case_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -14829,8 +14527,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -14856,8 +14552,6 @@ isset_dim_obj_exit:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14913,8 +14607,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14946,8 +14638,6 @@ array_key_exists_array:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -14995,8 +14685,6 @@ try_instanceof:
}
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15216,14 +14904,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -15279,13 +14963,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -15341,13 +15021,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -15402,14 +15078,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_not_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -15465,13 +15137,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -15527,13 +15195,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -16172,13 +15836,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
case_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
case_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -16266,8 +15926,6 @@ num_index_prop:
/* avoid exception check */
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -16293,8 +15951,6 @@ isset_dim_obj_exit:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16350,8 +16006,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16384,8 +16038,6 @@ array_key_exists_array:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -16433,8 +16085,6 @@ try_instanceof:
}
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -16641,8 +16291,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -16690,8 +16338,6 @@ try_instanceof:
}
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17483,13 +17129,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
case_true:
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
case_false:
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -17577,8 +17219,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -17604,8 +17244,6 @@ isset_dim_obj_exit:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17661,8 +17299,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17694,8 +17330,6 @@ array_key_exists_array:
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -18475,8 +18109,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HA
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -18492,8 +18124,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONS
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -18911,8 +18541,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE
}
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -19172,8 +18800,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HAND
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -19189,8 +18815,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21831,8 +21455,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HA
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21848,8 +21470,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONS
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -24164,8 +23784,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE
}
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26217,8 +25835,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HAND
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26234,8 +25850,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26429,8 +26043,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HAND
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26446,8 +26058,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_
zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -32116,8 +31726,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -33968,8 +33576,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -36571,8 +36177,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38278,12 +37882,8 @@ type_check_resource:
SAVE_OPLINE();
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
} else {
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
}
@@ -38586,8 +38186,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HAN
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38603,8 +38201,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38621,14 +38217,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -38684,13 +38276,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HA
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -38746,13 +38334,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_H
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -38807,14 +38391,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_not_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -38870,13 +38450,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -38932,13 +38508,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -41532,8 +41104,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -41559,8 +41129,6 @@ isset_dim_obj_exit:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41616,8 +41184,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41649,8 +41215,6 @@ array_key_exists_array:
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -41698,8 +41262,6 @@ try_instanceof:
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41955,8 +41517,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -42176,14 +41736,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -42239,13 +41795,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_H
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -42301,13 +41853,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -42362,14 +41910,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_not_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -42425,13 +41969,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -42487,13 +42027,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -45048,8 +44584,6 @@ num_index_prop:
/* avoid exception check */
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -45075,8 +44609,6 @@ isset_dim_obj_exit:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45132,8 +44664,6 @@ isset_object_finish:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45166,8 +44696,6 @@ array_key_exists_array:
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -45184,8 +44712,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDL
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45201,8 +44727,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_H
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45395,8 +44919,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDL
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45412,8 +44934,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_H
zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45535,8 +45055,6 @@ try_instanceof:
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -46621,25 +46139,15 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S
if (Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else {
int result;
SAVE_OPLINE();
result = !i_zend_is_true(value);
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH(result, 1);
}
}
@@ -46653,25 +46161,15 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S
if (Z_TYPE_P(value) > IS_NULL &&
(!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else {
int result;
SAVE_OPLINE();
result = !i_zend_is_true(value);
- if (UNEXPECTED(EG(exception))) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH(result, 1);
}
}
@@ -46716,8 +46214,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUS
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -46765,8 +46261,6 @@ try_instanceof:
}
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47232,8 +46726,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLE
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47249,8 +46741,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HA
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47267,14 +46757,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -47330,13 +46816,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDL
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -47392,13 +46874,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HAND
if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
is_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -47453,14 +46931,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE
if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
-
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_TRUE_NONE();
} else {
is_not_equal_false:
-
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
+ ZEND_VM_SMART_BRANCH_FALSE_NONE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -47516,13 +46990,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_H
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -47578,13 +47048,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_
if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
is_not_equal_true:
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
} else {
is_not_equal_false:
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
}
} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
d1 = (double)Z_LVAL_P(op1);
@@ -50207,8 +49673,6 @@ num_index_prop:
/* avoid exception check */
ZEND_VM_SMART_BRANCH(result, 0);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE();
}
} else {
result = (value == NULL || !i_zend_is_true(value));
@@ -50234,8 +49698,6 @@ isset_dim_obj_exit:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50291,8 +49753,6 @@ isset_object_finish:
ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50324,8 +49784,6 @@ array_key_exists_array:
ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
- Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -61537,9 +60995,9 @@ static const uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec
offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
} else if (spec & SPEC_RULE_SMART_BRANCH) {
offset = offset * 3;
- if ((op+1)->opcode == ZEND_JMPZ) {
+ if (op->result_type == IS_SMART_BRANCH_JMPZ) {
offset += 1;
- } else if ((op+1)->opcode == ZEND_JMPNZ) {
+ } else if (op->result_type == IS_SMART_BRANCH_JMPNZ) {
offset += 2;
}
}
diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 5f9a38ff9e..0839122dd0 100755
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -811,19 +811,19 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
($extra_spec['SMART_BRANCH'] == 1 ?
"ZEND_VM_SMART_BRANCH_JMPZ(\\1, \\2)"
: ($extra_spec['SMART_BRANCH'] == 2 ?
- "ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)" : ""))
+ "ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)" : "ZEND_VM_SMART_BRANCH_NONE(\\1, \\2)"))
: "ZEND_VM_SMART_BRANCH(\\1, \\2)",
"/ZEND_VM_SMART_BRANCH_TRUE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ?
($extra_spec['SMART_BRANCH'] == 1 ?
"ZEND_VM_SMART_BRANCH_TRUE_JMPZ()"
: ($extra_spec['SMART_BRANCH'] == 2 ?
- "ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()" : ""))
+ "ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()" : "ZEND_VM_SMART_BRANCH_TRUE_NONE()"))
: "ZEND_VM_SMART_BRANCH_TRUE()",
"/ZEND_VM_SMART_BRANCH_FALSE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ?
($extra_spec['SMART_BRANCH'] == 1 ?
"ZEND_VM_SMART_BRANCH_FALSE_JMPZ()"
: ($extra_spec['SMART_BRANCH'] == 2 ?
- "ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()" : ""))
+ "ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()" : "ZEND_VM_SMART_BRANCH_FALSE_NONE()"))
: "ZEND_VM_SMART_BRANCH_FALSE()",
"/opline->extended_value\s*&\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ?
($extra_spec['ISSET'] == 0 ? "0" : "1")
@@ -2746,9 +2746,9 @@ function gen_vm($def, $skel) {
if (isset($used_extra_spec["SMART_BRANCH"])) {
out($f, "\t\t{$else}if (spec & SPEC_RULE_SMART_BRANCH) {\n");
out($f, "\t\t\toffset = offset * 3;\n");
- out($f, "\t\t\tif ((op+1)->opcode == ZEND_JMPZ) {\n");
+ out($f, "\t\t\tif (op->result_type == IS_SMART_BRANCH_JMPZ) {\n");
out($f, "\t\t\t\toffset += 1;\n");
- out($f, "\t\t\t} else if ((op+1)->opcode == ZEND_JMPNZ) {\n");
+ out($f, "\t\t\t} else if (op->result_type == IS_SMART_BRANCH_JMPNZ) {\n");
out($f, "\t\t\t\toffset += 2;\n");
out($f, "\t\t\t}\n");
$else = "} else ";
diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index 6ca3d02468..775774124f 100644
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -73,15 +73,6 @@ static void strip_leading_nops(zend_op_array *op_array, zend_basic_block *b)
zend_op *opcodes = op_array->opcodes;
do {
- /* check if NOP breaks incorrect smart branch */
- if (b->len == 2
- && (opcodes[b->start + 1].opcode == ZEND_JMPZ
- || opcodes[b->start + 1].opcode == ZEND_JMPNZ)
- && (opcodes[b->start + 1].op1_type & (IS_CV|IS_CONST))
- && b->start > 0
- && zend_is_smart_branch(opcodes + b->start - 1)) {
- break;
- }
b->start++;
b->len--;
} while (b->len > 0 && opcodes[b->start].opcode == ZEND_NOP);
@@ -112,14 +103,6 @@ static void strip_nops(zend_op_array *op_array, zend_basic_block *b)
}
j++;
}
- if (i + 1 < b->start + b->len
- && (op_array->opcodes[i+1].opcode == ZEND_JMPZ
- || op_array->opcodes[i+1].opcode == ZEND_JMPNZ)
- && op_array->opcodes[i+1].op1_type & (IS_CV|IS_CONST)
- && zend_is_smart_branch(op_array->opcodes + j - 1)) {
- /* don't remove NOP, that splits incorrect smart branch */
- j++;
- }
i++;
}
b->len = j - b->start;
@@ -796,9 +779,20 @@ optimize_constant_binary_op:
if (zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
literal_dtor(&ZEND_OP1_LITERAL(opline));
literal_dtor(&ZEND_OP2_LITERAL(opline));
- opline->opcode = ZEND_QM_ASSIGN;
- SET_UNUSED(opline->op2);
- zend_optimizer_update_op1_const(op_array, opline, &result);
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (zend_is_true(&result) == (opline->result_type == IS_SMART_BRANCH_JMPNZ)) {
+ opline->opcode = ZEND_JMP;
+ COPY_NODE(opline->op1, opline->result);
+ SET_UNUSED(opline->op2);
+ SET_UNUSED(opline->result);
+ } else {
+ MAKE_NOP(opline);
+ }
+ } else {
+ opline->opcode = ZEND_QM_ASSIGN;
+ SET_UNUSED(opline->op2);
+ zend_optimizer_update_op1_const(op_array, opline, &result);
+ }
++(*opt_count);
}
}
@@ -1007,6 +1001,27 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start);
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ ZEND_SET_OP_JMP_ADDR(opline, opline->result, new_opcodes + blocks[b->successors[0]].start);
+ }
+ break;
}
}
@@ -1386,6 +1401,28 @@ next_target:
}
last_op->opcode = ZEND_JMPZNZ;
++(*opt_count);
+ break;
+ }
+
+ if (last_op->op1_type == IS_TMP_VAR) {
+ zend_op *src = last_op - 1;
+
+ while (src > op_array->opcodes + block->start && src->opcode == ZEND_NOP) {
+ src--;
+ }
+ if (src->result_type == IS_TMP_VAR
+ && src->result.var == last_op->op1.var
+ && zend_is_smart_branch(src)) {
+ block->len = src - (op_array->opcodes + block->start) + 1;
+ if (last_op->opcode == ZEND_JMPZ) {
+ src->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPZ;
+ } else {
+ src->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPNZ;
+ }
+ src->result.opline_num = last_op->op2.opline_num;
+ MAKE_NOP(last_op);
+ ++(*opt_count);
+ }
}
}
break;
@@ -1604,6 +1641,79 @@ next_target_znz:
}
}
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (last_op->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ zend_op *target;
+ zend_op *target_end;
+ zend_basic_block *target_block;
+
+ while (1) {
+ target_block = blocks + block->successors[1];
+ target = op_array->opcodes + target_block->start;
+ target_end = op_array->opcodes + target_block->start + 1;
+ while (target < target_end && target->opcode == ZEND_NOP) {
+ target++;
+ }
+
+ /* next block is only NOP's */
+ if (target == target_end && !(target_block->flags & ZEND_BB_PROTECTED)) {
+ DEL_SOURCE(block, block->successors[1]);
+ block->successors[1] = target_block->successors[0];
+ ADD_SOURCE(block, block->successors[1]);
+ ++(*opt_count);
+ } else {
+ break;
+ }
+ }
+
+ if (target->opcode == ZEND_JMP &&
+ !(target_block->flags & ZEND_BB_PROTECTED)) {
+
+ if (!(target_block->flags & ZEND_BB_TARGET)) {
+ int next = (target_block - blocks) + 1;
+
+ while (next < cfg->blocks_count && !(blocks[next].flags & ZEND_BB_REACHABLE)) {
+ /* find used one */
+ next++;
+ }
+ if (next < cfg->blocks_count &&
+ block->successors[0] == next) {
+ /* CMP_Z(X,L1) JMP(L2) L1: -> CMP_NZ(X,L2) NOP*/
+
+ last_op->result_type ^= (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ);
+
+ DEL_SOURCE(block, block->successors[1]);
+ block->successors[0] = target_block->successors[0];
+ block->successors[1] = next;
+ ADD_SOURCE(block, block->successors[1]);
+
+ target_block->flags &= ~ZEND_BB_REACHABLE;
+ MAKE_NOP(target);
+
+ blocks[next].flags |= ZEND_BB_FOLLOW;
+
+ break;
+ }
+ }
+ }
+ }
+ break;
}
}
}
diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c
index 8370bdc779..a9cc45bee8 100644
--- a/ext/opcache/Optimizer/dce.c
+++ b/ext/opcache/Optimizer/dce.c
@@ -78,12 +78,8 @@ static inline zend_bool may_have_side_effects(
zend_bool reorder_dtor_effects) {
switch (opline->opcode) {
case ZEND_NOP:
- case ZEND_IS_IDENTICAL:
- case ZEND_IS_NOT_IDENTICAL:
case ZEND_QM_ASSIGN:
case ZEND_FREE:
- case ZEND_TYPE_CHECK:
- case ZEND_DEFINED:
case ZEND_ADD:
case ZEND_SUB:
case ZEND_MUL:
@@ -101,11 +97,6 @@ static inline zend_bool may_have_side_effects(
case ZEND_BW_NOT:
case ZEND_SL:
case ZEND_SR:
- case ZEND_IS_EQUAL:
- case ZEND_IS_NOT_EQUAL:
- case ZEND_IS_SMALLER:
- case ZEND_IS_SMALLER_OR_EQUAL:
- case ZEND_CASE:
case ZEND_CAST:
case ZEND_ROPE_INIT:
case ZEND_ROPE_ADD:
@@ -116,16 +107,31 @@ static inline zend_bool may_have_side_effects(
case ZEND_COUNT:
case ZEND_GET_TYPE:
case ZEND_ISSET_ISEMPTY_THIS:
- case ZEND_ISSET_ISEMPTY_DIM_OBJ:
case ZEND_FETCH_DIM_IS:
- case ZEND_ISSET_ISEMPTY_CV:
- case ZEND_ISSET_ISEMPTY_VAR:
case ZEND_FETCH_IS:
- case ZEND_IN_ARRAY:
case ZEND_FUNC_NUM_ARGS:
case ZEND_FUNC_GET_ARGS:
/* No side effects */
return 0;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* For our purposes a jumps and branches are side effects. */
+ return 1;
+ } else {
+ return 0;
+ }
case ZEND_ROPE_END:
/* TODO: Rope dce optimization, see #76446 */
return 1;
diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c
index f3156e1fa5..10269dbf76 100644
--- a/ext/opcache/Optimizer/dfa_pass.c
+++ b/ext/opcache/Optimizer/dfa_pass.c
@@ -125,33 +125,6 @@ int zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx,
return SUCCESS;
}
-static zend_bool is_smart_branch_inhibiting_nop(
- zend_op_array *op_array, uint32_t target, uint32_t current,
- zend_basic_block *b, zend_basic_block *blocks_end)
-{
- uint32_t next;
- /* Target points one past the last non-nop instruction. Make sure there is one. */
- if (target == 0) {
- return 0;
- }
-
- /* Find the next instruction, skipping unreachable or empty blocks. */
- next = current + 1;
- if (next >= b->start + b->len) {
- do {
- b++;
- if (b == blocks_end) {
- return 0;
- }
- } while (!(b->flags & ZEND_BB_REACHABLE) || b->len == 0);
- next = b->start;
- }
-
- return (op_array->opcodes[next].opcode == ZEND_JMPZ ||
- op_array->opcodes[next].opcode == ZEND_JMPNZ) &&
- zend_is_smart_branch(op_array->opcodes + target - 1);
-}
-
static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_optimizer_ctx *ctx)
{
zend_basic_block *blocks = ssa->cfg.blocks;
@@ -199,8 +172,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
old_end = b->start + b->len;
while (i < old_end) {
shiftlist[i] = i - target;
- if (EXPECTED(op_array->opcodes[i].opcode != ZEND_NOP) ||
- is_smart_branch_inhibiting_nop(op_array, target, i, b, blocks_end)) {
+ if (EXPECTED(op_array->opcodes[i].opcode != ZEND_NOP)) {
if (i != target) {
op_array->opcodes[target] = op_array->opcodes[i];
ssa->ops[target] = ssa->ops[i];
@@ -653,6 +625,29 @@ static void zend_ssa_replace_control_link(zend_op_array *op_array, zend_ssa *ssa
}
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (ZEND_RESULT_JMP_ADDR(opline) == op_array->opcodes + old->start) {
+ ZEND_SET_OP_JMP_ADDR(opline, opline->result, op_array->opcodes + dst->start);
+ }
+ }
+ break;
}
}
@@ -951,6 +946,39 @@ optimize_jmpnz:
}
}
break;
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ zval tmp;
+
+ if (opline->op1_type == IS_CONST
+ && opline->op2_type != IS_CONST
+ && (OP2_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE
+ && Z_TYPE_INFO_P(CT_CONSTANT_EX(op_array, opline->op1.constant)) == IS_LONG
+ ) {
+
+// CMP long(?), #?.? [double] => #v.? = CMP double(?), #?.? [double]
+
+ zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant);
+ ZVAL_DOUBLE(&tmp, zval_get_double(zv));
+ opline->op1.constant = zend_optimizer_add_literal(op_array, &tmp);
+
+ } else if (opline->op1_type != IS_CONST
+ && opline->op2_type == IS_CONST
+ && (OP1_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE
+ && Z_TYPE_INFO_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == IS_LONG
+ ) {
+
+// CMP #?.? [double], long(?) => #v.? = CMP #?.? [double], double(?)
+
+ zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant);
+ ZVAL_DOUBLE(&tmp, zval_get_double(zv));
+ opline->op2.constant = zend_optimizer_add_literal(op_array, &tmp);
+ }
+ }
+ break;
case ZEND_NOP:
optimize_nop:
compress_block(op_array, block);
diff --git a/ext/opcache/Optimizer/pass1.c b/ext/opcache/Optimizer/pass1.c
index 2e9e547175..4d2fab097b 100644
--- a/ext/opcache/Optimizer/pass1.c
+++ b/ext/opcache/Optimizer/pass1.c
@@ -135,7 +135,16 @@ constant_binary_op:
if (zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
literal_dtor(&ZEND_OP1_LITERAL(opline));
literal_dtor(&ZEND_OP2_LITERAL(opline));
- if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, opline->result.var, &result)) {
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (zend_is_true(&result) == (opline->result_type == IS_SMART_BRANCH_JMPNZ)) {
+ opline->opcode = ZEND_JMP;
+ COPY_NODE(opline->op1, opline->result);
+ SET_UNUSED(opline->op2);
+ SET_UNUSED(opline->result);
+ } else {
+ MAKE_NOP(opline);
+ }
+ } else if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, opline->result.var, &result)) {
MAKE_NOP(opline);
} else {
opline->opcode = ZEND_QM_ASSIGN;
@@ -585,7 +594,16 @@ constant_binary_op:
}
ZVAL_TRUE(&c);
literal_dtor(&ZEND_OP1_LITERAL(opline));
- if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, opline->result.var, &c)) {
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (zend_is_true(&c) == (opline->result_type == IS_SMART_BRANCH_JMPNZ)) {
+ opline->opcode = ZEND_JMP;
+ COPY_NODE(opline->op1, opline->result);
+ SET_UNUSED(opline->op2);
+ SET_UNUSED(opline->result);
+ } else {
+ MAKE_NOP(opline);
+ }
+ } else if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, opline->result.var, &c)) {
MAKE_NOP(opline);
} else {
opline->opcode = ZEND_QM_ASSIGN;
diff --git a/ext/opcache/Optimizer/pass3.c b/ext/opcache/Optimizer/pass3.c
index 6e406f1127..d499084204 100644
--- a/ext/opcache/Optimizer/pass3.c
+++ b/ext/opcache/Optimizer/pass3.c
@@ -164,7 +164,20 @@ void zend_optimizer_pass3(zend_op_array *op_array, zend_optimizer_ctx *ctx)
} else {
MAKE_NOP(opline);
}
+ } else if (opline->op1_type == IS_TMP_VAR &&
+ opline > op_array->opcodes &&
+ zend_is_smart_branch(opline - 1) &&
+ (opline-1)->result_type == IS_TMP_VAR &&
+ (opline-1)->result.var == opline->op1.var) {
+ if (opline->opcode == ZEND_JMPZ) {
+ (opline-1)->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPZ;
+ } else {
+ ZEND_ASSERT(opline->opcode == ZEND_JMPNZ);
+ (opline-1)->result_type = IS_UNUSED | IS_SMART_BRANCH_JMPNZ;
+ }
+ (opline-1)->result.opline_num = opline->op2.opline_num;
}
+
break;
case ZEND_JMPZ_EX:
@@ -264,6 +277,35 @@ continue_jmpznz_optimization:
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, target);
}
break;
+
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ jmp_hitlist_count = 0;
+
+ target = ZEND_RESULT_JMP_ADDR(opline);
+ while (target->opcode == ZEND_JMP) {
+ target = ZEND_OP1_JMP_ADDR(target);
+ CHECK_JMP(target, done_jmp_optimization);
+ ZEND_SET_OP_JMP_ADDR(opline, opline->result, target);
+ }
+ }
+ break;
}
done_jmp_optimization:
opline++;
diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 57ae48b021..5aba24624c 100644
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -313,7 +313,6 @@ static zend_bool try_replace_op1(
case ZEND_INSTANCEOF:
zval_ptr_dtor_nogc(&zv);
ZVAL_FALSE(&zv);
- opline->opcode = ZEND_QM_ASSIGN;
opline->op1_type = IS_CONST;
opline->op1.constant = zend_optimizer_add_literal(ctx->scdf.op_array, &zv);
opline->op2_type = IS_UNUSED;
@@ -323,6 +322,17 @@ static zend_bool try_replace_op1(
ssa_op->op2_use = -1;
ssa_op->op2_use_chain = -1;
}
+ if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ opline->opcode = ZEND_JMPZ;
+ opline->op2.opline_num = opline->result.opline_num;
+ SET_UNUSED(opline->result);
+ } else if (opline->result_type == IS_SMART_BRANCH_JMPNZ) {
+ opline->opcode = ZEND_JMPNZ;
+ opline->op2.opline_num = opline->result.opline_num;
+ SET_UNUSED(opline->result);
+ } else {
+ opline->opcode = ZEND_QM_ASSIGN;
+ }
return 1;
default:
break;
@@ -1916,9 +1926,12 @@ static void sccp_mark_feasible_successors(
int block_num, zend_basic_block *block,
zend_op *opline, zend_ssa_op *ssa_op) {
sccp_ctx *ctx = (sccp_ctx *) scdf;
- zval *op1, zv;
+ zval *op1, *op2, zv;
int s;
+ op1 = get_op1_value(ctx, opline, ssa_op);
+ op2 = get_op2_value(ctx, opline, ssa_op);
+
/* We can't determine the branch target at compile-time for these */
switch (opline->opcode) {
case ZEND_ASSERT_CHECK:
@@ -1928,10 +1941,26 @@ static void sccp_mark_feasible_successors(
scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
return;
+ case ZEND_TYPE_CHECK:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* We may be able to evaluate TYPE_CHECK based on type inference info,
+ * even if we don't know the precise value. */
+ if (!value_known(op1)) {
+ uint32_t type = ctx->scdf.ssa->var_info[ssa_op->op1_use].type;
+ uint32_t expected_type_mask = opline->extended_value;
+ if (!(type & expected_type_mask) && !(type & MAY_BE_UNDEF)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[opline->result_type == IS_SMART_BRANCH_JMPNZ]);
+ return;
+ } else if (!(type & ((MAY_BE_ANY|MAY_BE_UNDEF) - expected_type_mask))
+ && !(expected_type_mask & MAY_BE_RESOURCE)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[opline->result_type == IS_SMART_BRANCH_JMPZ]);
+ return;
+ }
+ }
+ }
+ break;
}
- op1 = get_op1_value(ctx, opline, ssa_op);
-
/* Branch target can be either one */
if (!op1 || IS_BOT(op1)) {
for (s = 0; s < block->successors_count; s++) {
@@ -2021,6 +2050,157 @@ static void sccp_mark_feasible_successors(
}
s = 0;
break;
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_CASE:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* Branch target can be either one */
+ if (!op2 || IS_BOT(op2)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ /* Branch target not yet known */
+ if (IS_TOP(op2)) {
+ return;
+ }
+ if (ct_eval_binary_op(&zv, opline->opcode, op1, op2) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* Branch target can be either one */
+ if (!op2 || IS_BOT(op2)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ /* Branch target not yet known */
+ if (IS_TOP(op2)) {
+ return;
+ }
+ if (ct_eval_isset_dim(&zv, opline->extended_value, op1, op2) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* Branch target can be either one */
+ if (!op2 || IS_BOT(op2)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ /* Branch target not yet known */
+ if (IS_TOP(op2)) {
+ return;
+ }
+ if (ct_eval_isset_obj(&zv, opline->extended_value, op1, op2) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_ISSET_ISEMPTY_CV:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (ct_eval_isset_isempty(&zv, opline->extended_value, op1) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_INSTANCEOF:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ s = (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_TYPE_CHECK:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ ct_eval_type_check(&zv, opline->extended_value, op1);
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_IN_ARRAY:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* Branch target can be either one */
+ if (!op2 || IS_BOT(op2)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ /* Branch target not yet known */
+ if (IS_TOP(op2)) {
+ return;
+ }
+ if (ct_eval_in_array(&zv, opline->extended_value, op1, op2) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ /* Branch target can be either one */
+ if (!op2 || IS_BOT(op2)) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ /* Branch target not yet known */
+ if (IS_TOP(op2)) {
+ return;
+ }
+ if (ct_eval_array_key_exists(&zv, op1, op2) == FAILURE) {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[1]);
+ return;
+ }
+ s = (Z_TYPE(zv) == IS_TRUE) == (opline->result_type == IS_SMART_BRANCH_JMPZ);
+ break;
+ } else {
+ scdf_mark_edge_feasible(scdf, block_num, block->successors[0]);
+ return;
+ }
default:
for (s = 0; s < block->successors_count; s++) {
scdf_mark_edge_feasible(scdf, block_num, block->successors[s]);
diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c
index 5e0f137024..3bcad1c74a 100644
--- a/ext/opcache/Optimizer/zend_cfg.c
+++ b/ext/opcache/Optimizer/zend_cfg.c
@@ -397,21 +397,6 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
BB_START(i + 1);
break;
}
- case ZEND_FETCH_R:
- case ZEND_FETCH_W:
- case ZEND_FETCH_RW:
- case ZEND_FETCH_FUNC_ARG:
- case ZEND_FETCH_IS:
- case ZEND_FETCH_UNSET:
- case ZEND_UNSET_VAR:
- case ZEND_ISSET_ISEMPTY_VAR:
- if (opline->extended_value & ZEND_FETCH_LOCAL) {
- flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
- } else if ((opline->extended_value & (ZEND_FETCH_GLOBAL | ZEND_FETCH_GLOBAL_LOCK)) &&
- !op_array->function_name) {
- flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
- }
- break;
case ZEND_FUNC_GET_ARGS:
flags |= ZEND_FUNC_VARARG;
break;
@@ -431,6 +416,49 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
case ZEND_FE_FREE:
flags |= ZEND_FUNC_FREE_LOOP_VAR;
break;
+ case ZEND_FETCH_R:
+ case ZEND_FETCH_W:
+ case ZEND_FETCH_RW:
+ case ZEND_FETCH_FUNC_ARG:
+ case ZEND_FETCH_IS:
+ case ZEND_FETCH_UNSET:
+ case ZEND_UNSET_VAR:
+ if (opline->extended_value & ZEND_FETCH_LOCAL) {
+ flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
+ } else if ((opline->extended_value & (ZEND_FETCH_GLOBAL | ZEND_FETCH_GLOBAL_LOCK)) &&
+ !op_array->function_name) {
+ flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
+ }
+ break;
+ case ZEND_ISSET_ISEMPTY_VAR:
+ if (opline->extended_value & ZEND_FETCH_LOCAL) {
+ flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
+ } else if ((opline->extended_value & (ZEND_FETCH_GLOBAL | ZEND_FETCH_GLOBAL_LOCK)) &&
+ !op_array->function_name) {
+ flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
+ }
+ /* break missing intentionally */
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ BB_START(OP_JMP_ADDR(opline, opline->result) - op_array->opcodes);
+ BB_START(i + 1);
+ }
+ break;
}
}
@@ -569,6 +597,30 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
block->successors[s++] = j + 1;
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ block->successors_count = 2;
+ block->successors[0] = block_map[OP_JMP_ADDR(opline, opline->result) - op_array->opcodes];
+ block->successors[1] = j + 1;
+ break;
+ }
+ /* break missing intentionally */
default:
block->successors_count = 1;
block->successors[0] = j + 1;
diff --git a/ext/opcache/Optimizer/zend_cfg.h b/ext/opcache/Optimizer/zend_cfg.h
index 7d6ef25eee..009ea673f8 100644
--- a/ext/opcache/Optimizer/zend_cfg.h
+++ b/ext/opcache/Optimizer/zend_cfg.h
@@ -56,30 +56,31 @@ typedef struct _zend_basic_block {
} zend_basic_block;
/*
-+------------+---+---+---+---+---+
-| |OP1|OP2|EXT| 0 | 1 |
-+------------+---+---+---+---+---+
-|JMP |ADR| | |OP1| - |
-|JMPZ | |ADR| |OP2|FOL|
-|JMPNZ | |ADR| |OP2|FOL|
-|JMPZNZ | |ADR|ADR|OP2|EXT|
-|JMPZ_EX | |ADR| |OP2|FOL|
-|JMPNZ_EX | |ADR| |OP2|FOL|
-|JMP_SET | |ADR| |OP2|FOL|
-|COALESCE | |ADR| |OP2|FOL|
-|ASSERT_CHK | |ADR| |OP2|FOL|
-|NEW | |ADR| |OP2|FOL|
-|DCL_ANON* |ADR| | |OP1|FOL|
-|FE_RESET_* | |ADR| |OP2|FOL|
-|FE_FETCH_* | | |ADR|EXT|FOL|
-|CATCH | | |ADR|EXT|FOL|
-|FAST_CALL |ADR| | |OP1|FOL|
-|FAST_RET | | | | - | - |
-|RETURN* | | | | - | - |
-|EXIT | | | | - | - |
-|THROW | | | | - | - |
-|* | | | |FOL| - |
-+------------+---+---+---+---+---+
++------------+---+---+---+---+---+---+
+| |OP1|OP2|EXT|RES| 0 | 1 |
++------------+---+---+---+---+---+---+
+|JMP |ADR| | | |OP1| - |
+|JMPZ | |ADR| | |OP2|FOL|
+|JMPNZ | |ADR| | |OP2|FOL|
+|JMPZNZ | |ADR|ADR| |OP2|EXT|
+|JMPZ_EX | |ADR| | |OP2|FOL|
+|JMPNZ_EX | |ADR| | |OP2|FOL|
+|JMP_SET | |ADR| | |OP2|FOL|
+|COALESCE | |ADR| | |OP2|FOL|
+|ASSERT_CHK | |ADR| | |OP2|FOL|
+|NEW | |ADR| | |OP2|FOL|
+|DCL_ANON* |ADR| | | |OP1|FOL|
+|FE_RESET_* | |ADR| | |OP2|FOL|
+|FE_FETCH_* | | |ADR| |EXT|FOL|
+|CATCH | | |ADR| |EXT|FOL|
+|FAST_CALL |ADR| | | |OP1|FOL|
+|FAST_RET | | | | | - | - |
+|RETURN* | | | | | - | - |
+|EXIT | | | | | - | - |
+|THROW | | | | | - | - |
+|SMART_BRANCH| | | |ADR|RES|FOL|
+|* | | | | |FOL| - |
++------------+---+---+---+---+---+---+
*/
typedef struct _zend_cfg {
diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index d10e7f989e..6797dba595 100644
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -688,6 +688,18 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
}
if (opline->result_type == IS_CONST) {
zend_dump_const(CRT_CONSTANT_EX(op_array, opline, opline->result, (dump_flags & ZEND_DUMP_RT_CONSTANTS)));
+ } else if (opline->result_type == IS_SMART_BRANCH_JMPNZ) {
+ if (b) {
+ fprintf(stderr, " jmpnz BB%d", b->successors[n++]);
+ } else {
+ fprintf(stderr, " jmpnz L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->result) - op_array->opcodes));
+ }
+ } else if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ if (b) {
+ fprintf(stderr, " jmpz BB%d", b->successors[n++]);
+ } else {
+ fprintf(stderr, " jmpz L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->result) - op_array->opcodes));
+ }
} else if (ssa && ssa->ops && ssa->ops[opline - op_array->opcodes].result_use >= 0) {
if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
if (ssa && ssa->ops) {
diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 1307c5f9c8..c15d2457f9 100644
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -729,6 +729,27 @@ void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, z
new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (new_opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->result, ZEND_RESULT_JMP_ADDR(opline));
+ }
+ break;
}
}
@@ -773,6 +794,27 @@ void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_
opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]);
break;
}
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ ZEND_SET_OP_JMP_ADDR(opline, opline->result, ZEND_RESULT_JMP_ADDR(opline) - shiftlist[ZEND_RESULT_JMP_ADDR(opline) - op_array->opcodes]);
+ }
+ break;
}
}
@@ -1132,6 +1174,27 @@ static void zend_redo_pass_two(zend_op_array *op_array)
case ZEND_SWITCH_STRING:
/* relative extended_value don't have to be changed */
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ opline->result.jmp_addr = &op_array->opcodes[opline->result.jmp_addr - old_opcodes];
+ }
+ break;
}
}
#endif
@@ -1219,6 +1282,27 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa)
case ZEND_SWITCH_STRING:
/* relative extended_value don't have to be changed */
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ opline->result.jmp_addr = &op_array->opcodes[opline->result.jmp_addr - old_opcodes];
+ }
+ break;
}
}
#endif
diff --git a/ext/opcache/Optimizer/zend_optimizer_internal.h b/ext/opcache/Optimizer/zend_optimizer_internal.h
index d3ec873e4a..0f22eedc60 100644
--- a/ext/opcache/Optimizer/zend_optimizer_internal.h
+++ b/ext/opcache/Optimizer/zend_optimizer_internal.h
@@ -29,6 +29,7 @@
#define ZEND_OP1_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op1)
#define ZEND_OP2_LITERAL(opline) (op_array)->literals[(opline)->op2.constant]
#define ZEND_OP2_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op2)
+#define ZEND_RESULT_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->result)
#define VAR_NUM(v) EX_VAR_TO_NUM(v)
#define NUM_VAR(v) ((uint32_t)(zend_uintptr_t)ZEND_CALL_VAR_NUM(0, v))
diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index 4ef7afe705..011b2c6023 100644
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -221,6 +221,244 @@ static int find_adjusted_tmp_var(const zend_op_array *op_array, uint32_t build_f
}
/* }}} */
+static void place_essa_cmp_pi(
+ zend_arena **arena, const zend_op_array *op_array, uint32_t build_flags,
+ zend_ssa *ssa, zend_dfg *dfg, zend_op *opline, int j, int bt, int bf) /* {{{ */
+{
+ zend_ssa_phi *pi;
+ int var1 = -1;
+ int var2 = -1;
+ zend_long val1 = 0;
+ zend_long val2 = 0;
+
+ if (opline->op1_type == IS_CV) {
+ var1 = EX_VAR_TO_NUM(opline->op1.var);
+ } else if (opline->op1_type == IS_TMP_VAR) {
+ var1 = find_adjusted_tmp_var(
+ op_array, build_flags, opline, opline->op1.var, &val2);
+ }
+
+ if (opline->op2_type == IS_CV) {
+ var2 = EX_VAR_TO_NUM(opline->op2.var);
+ } else if (opline->op2_type == IS_TMP_VAR) {
+ var2 = find_adjusted_tmp_var(
+ op_array, build_flags, opline, opline->op2.var, &val1);
+ }
+
+ if (var1 >= 0 && var2 >= 0) {
+ if (!zend_sub_will_overflow(val1, val2) && !zend_sub_will_overflow(val2, val1)) {
+ zend_long tmp = val1;
+ val1 -= val2;
+ val2 -= tmp;
+ } else {
+ var1 = -1;
+ var2 = -1;
+ }
+ } else if (var1 >= 0 && var2 < 0) {
+ zend_long add_val2 = 0;
+ if (opline->op2_type == IS_CONST) {
+ zval *zv = CRT_CONSTANT_EX(op_array, opline, opline->op2, (build_flags & ZEND_RT_CONSTANTS));
+
+ if (Z_TYPE_P(zv) == IS_LONG) {
+ add_val2 = Z_LVAL_P(zv);
+ } else if (Z_TYPE_P(zv) == IS_FALSE) {
+ add_val2 = 0;
+ } else if (Z_TYPE_P(zv) == IS_TRUE) {
+ add_val2 = 1;
+ } else {
+ var1 = -1;
+ }
+ } else {
+ var1 = -1;
+ }
+ if (!zend_add_will_overflow(val2, add_val2)) {
+ val2 += add_val2;
+ } else {
+ var1 = -1;
+ }
+ } else if (var1 < 0 && var2 >= 0) {
+ zend_long add_val1 = 0;
+ if (opline->op1_type == IS_CONST) {
+ zval *zv = CRT_CONSTANT_EX(op_array, opline, opline->op1, (build_flags & ZEND_RT_CONSTANTS));
+ if (Z_TYPE_P(zv) == IS_LONG) {
+ add_val1 = Z_LVAL_P(CRT_CONSTANT_EX(op_array, opline, opline->op1, (build_flags & ZEND_RT_CONSTANTS)));
+ } else if (Z_TYPE_P(zv) == IS_FALSE) {
+ add_val1 = 0;
+ } else if (Z_TYPE_P(zv) == IS_TRUE) {
+ add_val1 = 1;
+ } else {
+ var2 = -1;
+ }
+ } else {
+ var2 = -1;
+ }
+ if (!zend_add_will_overflow(val1, add_val1)) {
+ val1 += add_val1;
+ } else {
+ var2 = -1;
+ }
+ }
+
+ if (var1 >= 0) {
+ if (opline->opcode == ZEND_IS_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
+ pi_range_equals(pi, var2, val2);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
+ pi_range_not_equals(pi, var2, val2);
+ }
+ } else if (opline->opcode == ZEND_IS_NOT_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
+ pi_range_equals(pi, var2, val2);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
+ pi_range_not_equals(pi, var2, val2);
+ }
+ } else if (opline->opcode == ZEND_IS_SMALLER) {
+ if (val2 > ZEND_LONG_MIN) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
+ pi_range_max(pi, var2, val2-1);
+ }
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
+ pi_range_min(pi, var2, val2);
+ }
+ } else if (opline->opcode == ZEND_IS_SMALLER_OR_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
+ pi_range_max(pi, var2, val2);
+ }
+ if (val2 < ZEND_LONG_MAX) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
+ pi_range_min(pi, var2, val2+1);
+ }
+ }
+ }
+ }
+ if (var2 >= 0) {
+ if(opline->opcode == ZEND_IS_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
+ pi_range_equals(pi, var1, val1);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
+ pi_range_not_equals(pi, var1, val1);
+ }
+ } else if (opline->opcode == ZEND_IS_NOT_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
+ pi_range_equals(pi, var1, val1);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
+ pi_range_not_equals(pi, var1, val1);
+ }
+ } else if (opline->opcode == ZEND_IS_SMALLER) {
+ if (val1 < ZEND_LONG_MAX) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
+ pi_range_min(pi, var1, val1+1);
+ }
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
+ pi_range_max(pi, var1, val1);
+ }
+ } else if (opline->opcode == ZEND_IS_SMALLER_OR_EQUAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
+ pi_range_min(pi, var1, val1);
+ }
+ if (val1 > ZEND_LONG_MIN) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
+ pi_range_max(pi, var1, val1-1);
+ }
+ }
+ }
+ }
+}
+/* }}} */
+
+static void place_essa_identical_pi(
+ zend_arena **arena, const zend_op_array *op_array, uint32_t build_flags,
+ zend_ssa *ssa, zend_dfg *dfg, zend_op *opline, int j, int bt, int bf) /* {{{ */
+{
+ zend_ssa_phi *pi;
+ int var;
+ zval *val;
+ uint32_t type_mask;
+
+ if (opline->op1_type == IS_CV && opline->op2_type == IS_CONST) {
+ var = EX_VAR_TO_NUM(opline->op1.var);
+ val = CRT_CONSTANT_EX(op_array, opline, opline->op2, (build_flags & ZEND_RT_CONSTANTS));
+ } else if (opline->op1_type == IS_CONST && opline->op2_type == IS_CV) {
+ var = EX_VAR_TO_NUM(opline->op2.var);
+ val = CRT_CONSTANT_EX(op_array, opline, opline->op1, (build_flags & ZEND_RT_CONSTANTS));
+ } else {
+ return;
+ }
+
+ /* We're interested in === null/true/false comparisons here, because they eliminate
+ * a type in the false-branch. Other === VAL comparisons are unlikely to be useful. */
+ if (Z_TYPE_P(val) != IS_NULL && Z_TYPE_P(val) != IS_TRUE && Z_TYPE_P(val) != IS_FALSE) {
+ return;
+ }
+
+ type_mask = _const_op_type(val);
+ if (opline->opcode == ZEND_IS_IDENTICAL) {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
+ pi_type_mask(pi, type_mask);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
+ pi_not_type_mask(pi, type_mask);
+ }
+ } else {
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
+ pi_type_mask(pi, type_mask);
+ }
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
+ pi_not_type_mask(pi, type_mask);
+ }
+ }
+}
+/* }}} */
+
+static void place_essa_type_check_pi(
+ zend_arena **arena, const zend_op_array *op_array, uint32_t build_flags,
+ zend_ssa *ssa, zend_dfg *dfg, zend_op *opline, int j, int bt, int bf) /* {{{ */
+{
+ zend_ssa_phi *pi;
+ int var = EX_VAR_TO_NUM(opline->op1.var);
+ uint32_t type = opline->extended_value;
+
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
+ pi_type_mask(pi, mask_for_type_check(type));
+ }
+ if (type != IS_RESOURCE) {
+ /* is_resource() may return false for closed resources */
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
+ pi_not_type_mask(pi, mask_for_type_check(type));
+ }
+ }
+}
+/* }}} */
+
+static void place_essa_instanceof_pi(
+ zend_arena **arena, const zend_script *script, const zend_op_array *op_array, uint32_t build_flags,
+ zend_ssa *ssa, zend_dfg *dfg, zend_op *opline, int j, int bt, int bf) /* {{{ */
+{
+ zend_ssa_phi *pi;
+ int var = EX_VAR_TO_NUM(opline->op1.var);
+ zend_string *lcname = Z_STR_P(CRT_CONSTANT_EX(op_array, opline, opline->op2, (build_flags & ZEND_RT_CONSTANTS)) + 1);
+ zend_class_entry *ce = script ? zend_hash_find_ptr(&script->class_table, lcname) : NULL;
+
+ if (!ce) {
+ ce = zend_hash_find_ptr(CG(class_table), lcname);
+ if (!ce || ce->type != ZEND_INTERNAL_CLASS) {
+ return;
+ }
+ }
+
+ if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
+ pi_type_mask(pi, MAY_BE_OBJECT);
+ pi->constraint.type.ce = ce;
+ }
+}
+/* }}} */
+
/* e-SSA construction: Pi placement (Pi is actually a Phi with single
* source and constraint).
* Order of Phis is importent, Pis must be placed before Phis
@@ -252,159 +490,78 @@ static void place_essa_pis(
bt = blocks[j].successors[0];
bf = blocks[j].successors[1];
break;
- default:
- continue;
- }
- if (opline->op1_type == IS_TMP_VAR &&
- ((opline-1)->opcode == ZEND_IS_EQUAL ||
- (opline-1)->opcode == ZEND_IS_NOT_EQUAL ||
- (opline-1)->opcode == ZEND_IS_SMALLER ||
- (opline-1)->opcode == ZEND_IS_SMALLER_OR_EQUAL) &&
- opline->op1.var == (opline-1)->result.var) {
- int var1 = -1;
- int var2 = -1;
- zend_long val1 = 0;
- zend_long val2 = 0;
-// long val = 0;
-
- if ((opline-1)->op1_type == IS_CV) {
- var1 = EX_VAR_TO_NUM((opline-1)->op1.var);
- } else if ((opline-1)->op1_type == IS_TMP_VAR) {
- var1 = find_adjusted_tmp_var(
- op_array, build_flags, opline, (opline-1)->op1.var, &val2);
- }
-
- if ((opline-1)->op2_type == IS_CV) {
- var2 = EX_VAR_TO_NUM((opline-1)->op2.var);
- } else if ((opline-1)->op2_type == IS_TMP_VAR) {
- var2 = find_adjusted_tmp_var(
- op_array, build_flags, opline, (opline-1)->op2.var, &val1);
- }
-
- if (var1 >= 0 && var2 >= 0) {
- if (!zend_sub_will_overflow(val1, val2) && !zend_sub_will_overflow(val2, val1)) {
- zend_long tmp = val1;
- val1 -= val2;
- val2 -= tmp;
- } else {
- var1 = -1;
- var2 = -1;
- }
- } else if (var1 >= 0 && var2 < 0) {
- zend_long add_val2 = 0;
- if ((opline-1)->op2_type == IS_CONST) {
- zval *zv = CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op2, (build_flags & ZEND_RT_CONSTANTS));
-
- if (Z_TYPE_P(zv) == IS_LONG) {
- add_val2 = Z_LVAL_P(zv);
- } else if (Z_TYPE_P(zv) == IS_FALSE) {
- add_val2 = 0;
- } else if (Z_TYPE_P(zv) == IS_TRUE) {
- add_val2 = 1;
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ bf = blocks[j].successors[0];
+ bt = blocks[j].successors[1];
} else {
- var1 = -1;
+ bt = blocks[j].successors[0];
+ bf = blocks[j].successors[1];
}
+ place_essa_cmp_pi(arena, op_array, build_flags, ssa, dfg, opline, j, bt, bf);
+ continue;
} else {
- var1 = -1;
+ continue;
}
- if (!zend_add_will_overflow(val2, add_val2)) {
- val2 += add_val2;
+ case ZEND_TYPE_CHECK:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ bf = blocks[j].successors[0];
+ bt = blocks[j].successors[1];
+ } else {
+ bt = blocks[j].successors[0];
+ bf = blocks[j].successors[1];
+ }
+ place_essa_type_check_pi(arena, op_array, build_flags, ssa, dfg, opline, j, bt, bf);
+ continue;
} else {
- var1 = -1;
+ continue;
}
- } else if (var1 < 0 && var2 >= 0) {
- zend_long add_val1 = 0;
- if ((opline-1)->op1_type == IS_CONST) {
- zval *zv = CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op1, (build_flags & ZEND_RT_CONSTANTS));
- if (Z_TYPE_P(zv) == IS_LONG) {
- add_val1 = Z_LVAL_P(CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op1, (build_flags & ZEND_RT_CONSTANTS)));
- } else if (Z_TYPE_P(zv) == IS_FALSE) {
- add_val1 = 0;
- } else if (Z_TYPE_P(zv) == IS_TRUE) {
- add_val1 = 1;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ bf = blocks[j].successors[0];
+ bt = blocks[j].successors[1];
} else {
- var2 = -1;
+ bt = blocks[j].successors[0];
+ bf = blocks[j].successors[1];
}
+ place_essa_identical_pi(arena, op_array, build_flags, ssa, dfg, opline, j, bt, bf);
+ continue;
} else {
- var2 = -1;
+ continue;
}
- if (!zend_add_will_overflow(val1, add_val1)) {
- val1 += add_val1;
+ case ZEND_INSTANCEOF:
+ if ((opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ))
+ && opline->op2_type == IS_CONST) {
+ if (opline->result_type == IS_SMART_BRANCH_JMPZ) {
+ bf = blocks[j].successors[0];
+ bt = blocks[j].successors[1];
+ } else {
+ bt = blocks[j].successors[0];
+ bf = blocks[j].successors[1];
+ }
+ place_essa_instanceof_pi(arena, script, op_array, build_flags, ssa, dfg, opline, j, bt, bf);
+ continue;
} else {
- var2 = -1;
+ continue;
}
- }
+ default:
+ continue;
+ }
+ if (opline->op1_type == IS_TMP_VAR &&
+ ((opline-1)->opcode == ZEND_IS_EQUAL ||
+ (opline-1)->opcode == ZEND_IS_NOT_EQUAL ||
+ (opline-1)->opcode == ZEND_IS_SMALLER ||
+ (opline-1)->opcode == ZEND_IS_SMALLER_OR_EQUAL) &&
+ opline->op1.var == (opline-1)->result.var) {
- if (var1 >= 0) {
- if ((opline-1)->opcode == ZEND_IS_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
- pi_range_equals(pi, var2, val2);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
- pi_range_not_equals(pi, var2, val2);
- }
- } else if ((opline-1)->opcode == ZEND_IS_NOT_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
- pi_range_equals(pi, var2, val2);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
- pi_range_not_equals(pi, var2, val2);
- }
- } else if ((opline-1)->opcode == ZEND_IS_SMALLER) {
- if (val2 > ZEND_LONG_MIN) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
- pi_range_max(pi, var2, val2-1);
- }
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
- pi_range_min(pi, var2, val2);
- }
- } else if ((opline-1)->opcode == ZEND_IS_SMALLER_OR_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var1))) {
- pi_range_max(pi, var2, val2);
- }
- if (val2 < ZEND_LONG_MAX) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var1))) {
- pi_range_min(pi, var2, val2+1);
- }
- }
- }
- }
- if (var2 >= 0) {
- if((opline-1)->opcode == ZEND_IS_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
- pi_range_equals(pi, var1, val1);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
- pi_range_not_equals(pi, var1, val1);
- }
- } else if ((opline-1)->opcode == ZEND_IS_NOT_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
- pi_range_equals(pi, var1, val1);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
- pi_range_not_equals(pi, var1, val1);
- }
- } else if ((opline-1)->opcode == ZEND_IS_SMALLER) {
- if (val1 < ZEND_LONG_MAX) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
- pi_range_min(pi, var1, val1+1);
- }
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
- pi_range_max(pi, var1, val1);
- }
- } else if ((opline-1)->opcode == ZEND_IS_SMALLER_OR_EQUAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var2))) {
- pi_range_min(pi, var1, val1);
- }
- if (val1 > ZEND_LONG_MIN) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var2))) {
- pi_range_max(pi, var1, val1-1);
- }
- }
- }
- }
+ place_essa_cmp_pi(arena, op_array, build_flags, ssa, dfg, opline - 1, j, bt, bf);
} else if (opline->op1_type == IS_TMP_VAR &&
((opline-1)->opcode == ZEND_POST_INC ||
(opline-1)->opcode == ZEND_POST_DEC) &&
@@ -443,73 +600,16 @@ static void place_essa_pis(
}
} else if (opline->op1_type == IS_TMP_VAR && (opline-1)->opcode == ZEND_TYPE_CHECK &&
opline->op1.var == (opline-1)->result.var && (opline-1)->op1_type == IS_CV) {
- int var = EX_VAR_TO_NUM((opline-1)->op1.var);
- uint32_t type = (opline-1)->extended_value;
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
- pi_type_mask(pi, mask_for_type_check(type));
- }
- if (type != IS_RESOURCE) {
- /* is_resource() may return false for closed resources */
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
- pi_not_type_mask(pi, mask_for_type_check(type));
- }
- }
+ place_essa_type_check_pi(arena, op_array, build_flags, ssa, dfg, opline-1, j, bt, bf);
} else if (opline->op1_type == IS_TMP_VAR &&
((opline-1)->opcode == ZEND_IS_IDENTICAL
|| (opline-1)->opcode == ZEND_IS_NOT_IDENTICAL) &&
opline->op1.var == (opline-1)->result.var) {
- int var;
- zval *val;
- uint32_t type_mask;
- if ((opline-1)->op1_type == IS_CV && (opline-1)->op2_type == IS_CONST) {
- var = EX_VAR_TO_NUM((opline-1)->op1.var);
- val = CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op2, (build_flags & ZEND_RT_CONSTANTS));
- } else if ((opline-1)->op1_type == IS_CONST && (opline-1)->op2_type == IS_CV) {
- var = EX_VAR_TO_NUM((opline-1)->op2.var);
- val = CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op1, (build_flags & ZEND_RT_CONSTANTS));
- } else {
- continue;
- }
-
- /* We're interested in === null/true/false comparisons here, because they eliminate
- * a type in the false-branch. Other === VAL comparisons are unlikely to be useful. */
- if (Z_TYPE_P(val) != IS_NULL && Z_TYPE_P(val) != IS_TRUE && Z_TYPE_P(val) != IS_FALSE) {
- continue;
- }
-
- type_mask = _const_op_type(val);
- if ((opline-1)->opcode == ZEND_IS_IDENTICAL) {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
- pi_type_mask(pi, type_mask);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
- pi_not_type_mask(pi, type_mask);
- }
- } else {
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bf, var))) {
- pi_type_mask(pi, type_mask);
- }
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
- pi_not_type_mask(pi, type_mask);
- }
- }
+ place_essa_identical_pi(arena, op_array, build_flags, ssa, dfg, opline-1, j, bt, bf);
} else if (opline->op1_type == IS_TMP_VAR && (opline-1)->opcode == ZEND_INSTANCEOF &&
opline->op1.var == (opline-1)->result.var && (opline-1)->op1_type == IS_CV &&
(opline-1)->op2_type == IS_CONST) {
- int var = EX_VAR_TO_NUM((opline-1)->op1.var);
- zend_string *lcname = Z_STR_P(CRT_CONSTANT_EX(op_array, (opline-1), (opline-1)->op2, (build_flags & ZEND_RT_CONSTANTS)) + 1);
- zend_class_entry *ce = script ? zend_hash_find_ptr(&script->class_table, lcname) : NULL;
- if (!ce) {
- ce = zend_hash_find_ptr(CG(class_table), lcname);
- if (!ce || ce->type != ZEND_INTERNAL_CLASS) {
- continue;
- }
- }
-
- if ((pi = add_pi(arena, op_array, dfg, ssa, j, bt, var))) {
- pi_type_mask(pi, MAY_BE_OBJECT);
- pi->constraint.type.ce = ce;
- }
+ place_essa_instanceof_pi(arena, script, op_array, build_flags, ssa, dfg, opline-1, j, bt, bf);
}
}
}
diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 663f511bc1..4f2aa490b9 100644
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -476,6 +476,27 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra
case ZEND_SWITCH_STRING:
/* relative extended_value don't have to be changed */
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ SERIALIZE_PTR(opline->result.jmp_addr);
+ }
+ break;
}
#endif
zend_serialize_opcode_handler(opline);
@@ -1181,6 +1202,27 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr
case ZEND_SWITCH_STRING:
/* relative extended_value don't have to be changed */
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ UNSERIALIZE_PTR(opline->result.jmp_addr);
+ }
+ break;
}
#endif
zend_deserialize_opcode_handler(opline);
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index a2fb94d7f6..e259e539d5 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -463,6 +463,27 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
case ZEND_SWITCH_STRING:
/* relative extended_value don't have to be changed */
break;
+ case ZEND_IS_IDENTICAL:
+ case ZEND_IS_NOT_IDENTICAL:
+ case ZEND_IS_EQUAL:
+ case ZEND_IS_NOT_EQUAL:
+ case ZEND_IS_SMALLER:
+ case ZEND_IS_SMALLER_OR_EQUAL:
+ case ZEND_CASE:
+ case ZEND_ISSET_ISEMPTY_CV:
+ case ZEND_ISSET_ISEMPTY_VAR:
+ case ZEND_ISSET_ISEMPTY_DIM_OBJ:
+ case ZEND_ISSET_ISEMPTY_PROP_OBJ:
+ case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+ case ZEND_INSTANCEOF:
+ case ZEND_TYPE_CHECK:
+ case ZEND_DEFINED:
+ case ZEND_IN_ARRAY:
+ case ZEND_ARRAY_KEY_EXISTS:
+ if (opline->result_type & (IS_SMART_BRANCH_JMPZ|IS_SMART_BRANCH_JMPNZ)) {
+ opline->result.jmp_addr = &new_opcodes[opline->result.jmp_addr - op_array->opcodes];
+ }
+ break;
}
}
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment