Implement ??= operator

RFC: https://wiki.php.net/rfc/null_coalesce_equal_operator

$a ??= $b is $a ?? ($a = $b), with the difference that $a is only
evaluated once, to the degree that this is possible. In particular
in $a[foo()] ?? $b function foo() is only ever called once.
However, the variable access themselves will be reevaluated.

diff --git a/UPGRADING b/UPGRADING
index abfc787fbf8ca6ec6b38250ee37d5fb695c04687..768298159d0d5dfd099275eb9b8ef806f46ecd81 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -90,6 +90,15 @@ PHP 7.4 UPGRADE NOTES
     This will enforce that $user->id can only be assigned integer and
     $user->name can only be assigned strings. For more information see the
     RFC: https://wiki.php.net/rfc/typed_properties_v2
+  . Added support for coalesce assign (??=) operator. For example:
+
+        $array['key'] ??= computeDefault();
+        // is roughly equivalent to
+        if (!isset($array['key'])) {
+            $array['key'] = computeDefault();
+        }
+
+    RFC: https://wiki.php.net/rfc/null_coalesce_equal_operator
 
 - FFI:
   . A new extension which provides a simple way to call native functions, access

diff --git a/Zend/tests/assign_coalesce_001.phpt b/Zend/tests/assign_coalesce_001.phpt
new file mode 100644 (file)
index 0000000..163f72f
--- /dev/null
+++ b/Zend/tests/assign_coalesce_001.phpt
@@ -0,0 +1,127 @@
+--TEST--
+Coalesce assign (??=): Basic behavior
+--FILE--
+<?php
+
+// Refcounted values
+$foo = "fo";
+$foo .= "o";
+$bar = "ba";
+$bar .= "r";
+
+// Identity function used to track single-evaluation
+function id($arg) {
+    echo "id($arg)\n";
+    return $arg;
+}
+
+echo "Simple variables:\n";
+$a = 123;
+$a ??= 456;
+var_dump($a);
+
+$b = null;
+$b ??= $foo;
+var_dump($b);
+
+$c = $foo;
+$c ??= $bar;
+var_dump($c);
+
+$d ??= $foo;
+var_dump($c);
+
+echo "\nArrays:\n";
+$ary = [];
+$ary["foo"] ??= 123;
+$ary[$foo] ??= $bar;
+$ary[$bar] ??= $foo;
+var_dump($ary);
+
+$ary = [];
+$ary[id($foo)] ??= 123;
+$ary[id($foo)] ??= $bar;
+$ary[id($bar)] ??= $foo;
+var_dump($ary);
+
+echo "\nObjects:\n";
+$obj = new stdClass;
+$obj->foo ??= 123;
+$obj->$foo ??= $bar;
+$obj->$bar ??= $foo;
+var_dump($obj);
+
+$obj = new stdClass;
+$obj->{id($foo)} ??= 123;
+$obj->{id($foo)} ??= $bar;
+$obj->{id($bar)} ??= $foo;
+var_dump($obj);
+
+class Test {
+    public static $foo;
+    public static $bar;
+}
+
+echo "\nStatic props:\n";
+Test::$foo ??= 123;
+Test::$$foo ??= $bar;
+Test::$$bar ??= $foo;
+var_dump(Test::$foo, Test::$bar);
+
+Test::$foo = null;
+Test::$bar = null;
+Test::${id($foo)} ??= 123;
+Test::${id($foo)} ??= $bar;
+Test::${id($bar)} ??= $foo;
+var_dump(Test::$foo, Test::$bar);
+
+?>
+--EXPECT--
+Simple variables:
+int(123)
+string(3) "foo"
+string(3) "foo"
+string(3) "foo"
+
+Arrays:
+array(2) {
+  ["foo"]=>
+  int(123)
+  ["bar"]=>
+  string(3) "foo"
+}
+id(foo)
+id(foo)
+id(bar)
+array(2) {
+  ["foo"]=>
+  int(123)
+  ["bar"]=>
+  string(3) "foo"
+}
+
+Objects:
+object(stdClass)#1 (2) {
+  ["foo"]=>
+  int(123)
+  ["bar"]=>
+  string(3) "foo"
+}
+id(foo)
+id(foo)
+id(bar)
+object(stdClass)#2 (2) {
+  ["foo"]=>
+  int(123)
+  ["bar"]=>
+  string(3) "foo"
+}
+
+Static props:
+int(123)
+string(3) "foo"
+id(foo)
+id(foo)
+id(bar)
+int(123)
+string(3) "foo"

diff --git a/Zend/tests/assign_coalesce_002.phpt b/Zend/tests/assign_coalesce_002.phpt
new file mode 100644 (file)
index 0000000..e49544e
--- /dev/null
+++ b/Zend/tests/assign_coalesce_002.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Coalesce assign (??=): Exception handling
+--FILE--
+<?php
+
+$foo = "fo";
+$foo .= "o";
+$bar = "ba";
+$bar .= "r";
+
+function id($arg) {
+    echo "id($arg)\n";
+    return $arg;
+}
+
+function do_throw($msg) {
+    throw new Exception($msg);
+}
+
+$ary = [];
+try {
+    $ary[id($foo)] ??= do_throw("ex1");
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($ary);
+
+class AA implements ArrayAccess {
+    public function offsetExists($k) {
+        return true;
+    }
+    public function &offsetGet($k) {
+        $var = ["foo" => "bar"];
+        return $var;
+    }
+    public function offsetSet($k,$v) {}
+    public function offsetUnset($k) {}
+}
+
+class Dtor {
+    public function __destruct() {
+        throw new Exception("dtor");
+    }
+}
+
+$ary = new AA;
+try {
+    $ary[new Dtor][id($foo)] ??= $bar;
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($foo);
+
+class AA2 implements ArrayAccess {
+    public function offsetExists($k) {
+        return false;
+    }
+    public function offsetGet($k) {
+        return null;
+    }
+    public function offsetSet($k,$v) {}
+    public function offsetUnset($k) {}
+}
+
+$ary = ["foo" => new AA2];
+try {
+    $ary[id($foo)][new Dtor] ??= $bar;
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($foo);
+
+?>
+--EXPECT--
+id(foo)
+ex1
+array(0) {
+}
+id(foo)
+dtor
+string(3) "foo"
+id(foo)
+dtor
+string(3) "foo"

diff --git a/Zend/tests/assign_coalesce_003.phpt b/Zend/tests/assign_coalesce_003.phpt
new file mode 100644 (file)
index 0000000..8509aa1
--- /dev/null
+++ b/Zend/tests/assign_coalesce_003.phpt
@@ -0,0 +1,70 @@
+--TEST--
+Coalesce assign (??=): ArrayAccess handling
+--FILE--
+<?php
+
+function id($arg) {
+    echo "id($arg)\n";
+    return $arg;
+}
+
+class AA implements ArrayAccess {
+    public $data;
+    public function __construct($data = []) {
+        $this->data = $data;
+    }
+    public function &offsetGet($k) {
+        echo "offsetGet($k)\n";
+        return $this->data[$k];
+    }
+    public function offsetExists($k) {
+        echo "offsetExists($k)\n";
+        return array_key_exists($k, $this->data);
+    }
+    public function offsetSet($k,$v) {
+        echo "offsetSet($k,$v)\n";
+        $this->data[$k] = $v;
+    }
+    public function offsetUnset($k) { }
+}
+
+$ary = new AA(["foo" => new AA, "null" => null]);
+
+echo "[foo]\n";
+$ary["foo"] ??= "bar";
+
+echo "[bar]\n";
+$ary["bar"] ??= "foo";
+
+echo "[null]\n";
+$ary["null"] ??= "baz";
+
+echo "[foo][bar]\n";
+$ary["foo"]["bar"] ??= "abc";
+
+echo "[foo][bar]\n";
+$ary["foo"]["bar"] ??= "def";
+
+?>
+--EXPECT--
+[foo]
+offsetExists(foo)
+offsetGet(foo)
+[bar]
+offsetExists(bar)
+offsetSet(bar,foo)
+[null]
+offsetExists(null)
+offsetGet(null)
+offsetSet(null,baz)
+[foo][bar]
+offsetExists(foo)
+offsetGet(foo)
+offsetExists(bar)
+offsetGet(foo)
+offsetSet(bar,abc)
+[foo][bar]
+offsetExists(foo)
+offsetGet(foo)
+offsetExists(bar)
+offsetGet(bar)

diff --git a/Zend/tests/assign_coalesce_004.phpt b/Zend/tests/assign_coalesce_004.phpt
new file mode 100644 (file)
index 0000000..51b9d2f
--- /dev/null
+++ b/Zend/tests/assign_coalesce_004.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Coalesce assign (??=): Non-writable variable
+--FILE--
+<?php
+
+function foo() { return 123; }
+foo() ??= 456;
+
+?>
+--EXPECTF--
+Fatal error: Can't use function return value in write context in %s on line %d

diff --git a/Zend/tests/assign_coalesce_005.phpt b/Zend/tests/assign_coalesce_005.phpt
new file mode 100644 (file)
index 0000000..2051010
--- /dev/null
+++ b/Zend/tests/assign_coalesce_005.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Coalesce assign (??=): Cannot reassign $this
+--FILE--
+<?php
+
+class Test {
+    public function foobar() {
+        $this ??= 123;
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot re-assign $this in %s on line %d

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 8ddf8ea9abc55dd83763be24928f690deb6c7f8f..a679fcf69005ea0d687dcda63c7c55190b476817 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -1672,6 +1672,7 @@ simple_list:
                                EMPTY_SWITCH_DEFAULT_CASE();
                        }
                        break;
+               case ZEND_AST_ASSIGN_COALESCE: BINARY_OP(" \?\?= ", 90, 91, 90);
                case ZEND_AST_BINARY_OP:
                        switch (ast->attr) {
                                case ZEND_ADD:                 BINARY_OP(" + ",   200, 200, 201);

diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index 9600b801ca0f5eaaf7e35836bf2a897b6ec04bf7..5716296bbd453a147bb52d5b7397d8c592f3a7c9 100644 (file)
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -120,6 +120,7 @@ enum _zend_ast_kind {
        ZEND_AST_INSTANCEOF,
        ZEND_AST_YIELD,
        ZEND_AST_COALESCE,
+       ZEND_AST_ASSIGN_COALESCE,
 
        ZEND_AST_STATIC,
        ZEND_AST_WHILE,

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 58792e9216b6f8b075bbf0a84fe670d1ed5b021d..a6fe6954b7b4ca9339a725db79f44d4ec0958279 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -332,6 +332,8 @@ void zend_init_compiler_data_structures(void) /* {{{ */
        CG(start_lineno) = 0;
 
        CG(encoding_declared) = 0;
+       CG(memoized_exprs) = NULL;
+       CG(memoize_mode) = 0;
 }
 /* }}} */
 
@@ -1900,6 +1902,7 @@ static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_t
                case ZEND_JMPZ_EX:
                case ZEND_JMPNZ_EX:
                case ZEND_JMP_SET:
+               case ZEND_COALESCE:
                        opline->op2.opline_num = opnum_target;
                        break;
                EMPTY_SWITCH_DEFAULT_CASE()
@@ -1956,6 +1959,43 @@ static zend_op *zend_delayed_compile_end(uint32_t offset) /* {{{ */
 }
 /* }}} */
 
+#define ZEND_MEMOIZE_NONE 0
+#define ZEND_MEMOIZE_COMPILE 1
+#define ZEND_MEMOIZE_FETCH 2
+
+static void zend_compile_memoized_expr(znode *result, zend_ast *expr) /* {{{ */
+{
+       int memoize_mode = CG(memoize_mode);
+       if (memoize_mode == ZEND_MEMOIZE_COMPILE) {
+               znode memoized_result;
+
+               /* Go through normal compilation */
+               CG(memoize_mode) = ZEND_MEMOIZE_NONE;
+               zend_compile_expr(result, expr);
+               CG(memoize_mode) = ZEND_MEMOIZE_COMPILE;
+
+               if (result->op_type == IS_VAR) {
+                       zend_emit_op(&memoized_result, ZEND_COPY_TMP, result, NULL);
+               } else if (result->op_type == IS_TMP_VAR) {
+                       zend_emit_op_tmp(&memoized_result, ZEND_COPY_TMP, result, NULL);
+               } else {
+                       memoized_result = *result;
+               }
+
+               zend_hash_index_update_mem(
+                       CG(memoized_exprs), (uintptr_t) expr, &memoized_result, sizeof(znode));
+       } else if (memoize_mode == ZEND_MEMOIZE_FETCH) {
+               znode *memoized_result = zend_hash_index_find_ptr(CG(memoized_exprs), (uintptr_t) expr);
+               *result = *memoized_result;
+               if (result->op_type == IS_CONST) {
+                       Z_TRY_ADDREF(result->u.constant);
+               }
+       } else {
+               ZEND_ASSERT(0);
+       }
+}
+/* }}} */
+
 static void zend_emit_return_type_check(
                znode *expr, zend_arg_info *return_info, zend_bool implicit) /* {{{ */
 {
@@ -7220,6 +7260,100 @@ void zend_compile_coalesce(znode *result, zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
+static void znode_dtor(zval *zv) {
+       efree(Z_PTR_P(zv));
+}
+
+void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */
+{
+       zend_ast *var_ast = ast->child[0];
+       zend_ast *default_ast = ast->child[1];
+
+       znode var_node_is, var_node_w, default_node, assign_node, *node;
+       zend_op *opline;
+       uint32_t coalesce_opnum;
+       zend_bool need_frees = 0;
+
+       /* Remember expressions compiled during the initial BP_VAR_IS lookup,
+        * to avoid double-evaluation when we compile again with BP_VAR_W. */
+       HashTable *orig_memoized_exprs = CG(memoized_exprs);
+       int orig_memoize_mode = CG(memoize_mode);
+
+       zend_ensure_writable_variable(var_ast);
+       if (is_this_fetch(var_ast)) {
+               zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
+       }
+
+       ALLOC_HASHTABLE(CG(memoized_exprs));
+       zend_hash_init(CG(memoized_exprs), 0, NULL, znode_dtor, 0);
+
+       CG(memoize_mode) = ZEND_MEMOIZE_COMPILE;
+       zend_compile_var(&var_node_is, var_ast, BP_VAR_IS, 0);
+
+       coalesce_opnum = get_next_op_number();
+       zend_emit_op_tmp(result, ZEND_COALESCE, &var_node_is, NULL);
+
+       CG(memoize_mode) = ZEND_MEMOIZE_NONE;
+       zend_compile_expr(&default_node, default_ast);
+
+       CG(memoize_mode) = ZEND_MEMOIZE_FETCH;
+       zend_compile_var(&var_node_w, var_ast, BP_VAR_W, 0);
+
+       /* Reproduce some of the zend_compile_assign() opcode fixup logic here. */
+       opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
+       switch (var_ast->kind) {
+               case ZEND_AST_VAR:
+                       zend_emit_op(&assign_node, ZEND_ASSIGN, &var_node_w, &default_node);
+                       break;
+               case ZEND_AST_STATIC_PROP:
+                       opline->opcode = ZEND_ASSIGN_STATIC_PROP;
+                       zend_emit_op_data(&default_node);
+                       assign_node = var_node_w;
+                       break;
+               case ZEND_AST_DIM:
+                       opline->opcode = ZEND_ASSIGN_DIM;
+                       zend_emit_op_data(&default_node);
+                       assign_node = var_node_w;
+                       break;
+               case ZEND_AST_PROP:
+                       opline->opcode = ZEND_ASSIGN_OBJ;
+                       zend_emit_op_data(&default_node);
+                       assign_node = var_node_w;
+                       break;
+               EMPTY_SWITCH_DEFAULT_CASE();
+       }
+
+       opline = zend_emit_op_tmp(NULL, ZEND_QM_ASSIGN, &assign_node, NULL);
+       SET_NODE(opline->result, result);
+
+       ZEND_HASH_FOREACH_PTR(CG(memoized_exprs), node) {
+               if (node->op_type == IS_TMP_VAR || node->op_type == IS_VAR) {
+                       need_frees = 1;
+                       break;
+               }
+       } ZEND_HASH_FOREACH_END();
+
+       /* Free DUPed expressions if there are any */
+       if (need_frees) {
+               uint32_t jump_opnum = zend_emit_jump(0);
+               zend_update_jump_target_to_next(coalesce_opnum);
+               ZEND_HASH_FOREACH_PTR(CG(memoized_exprs), node) {
+                       if (node->op_type == IS_TMP_VAR || node->op_type == IS_VAR) {
+                               zend_emit_op(NULL, ZEND_FREE, node, NULL);
+                       }
+               } ZEND_HASH_FOREACH_END();
+               zend_update_jump_target_to_next(jump_opnum);
+       } else {
+               zend_update_jump_target_to_next(coalesce_opnum);
+       }
+
+       zend_hash_destroy(CG(memoized_exprs));
+       FREE_HASHTABLE(CG(memoized_exprs));
+       CG(memoized_exprs) = orig_memoized_exprs;
+       CG(memoize_mode) = orig_memoize_mode;
+}
+/* }}} */
+
 void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */
 {
        zend_op *opline;
@@ -8105,6 +8239,11 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */
        /* CG(zend_lineno) = ast->lineno; */
        CG(zend_lineno) = zend_ast_get_lineno(ast);
 
+       if (CG(memoize_mode) != ZEND_MEMOIZE_NONE) {
+               zend_compile_memoized_expr(result, ast);
+               return;
+       }
+
        switch (ast->kind) {
                case ZEND_AST_ZVAL:
                        ZVAL_COPY(&result->u.constant, zend_ast_get_zval(ast));
@@ -8172,6 +8311,9 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */
                case ZEND_AST_COALESCE:
                        zend_compile_coalesce(result, ast);
                        return;
+               case ZEND_AST_ASSIGN_COALESCE:
+                       zend_compile_assign_coalesce(result, ast);
+                       return;
                case ZEND_AST_PRINT:
                        zend_compile_print(result, ast);
                        return;

diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 460e0056e031c6436be7c7db7848121abb43d9a8..d558fa9ad8518bd6e91dd57eff20b02ef568a645 100644 (file)
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -116,6 +116,8 @@ struct _zend_compiler_globals {
        zend_arena *ast_arena;
 
        zend_stack delayed_oplines_stack;
+       HashTable *memoized_exprs;
+       int memoize_mode;
 
        void   *map_ptr_base;
        size_t  map_ptr_size;

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index c1902303c28d6230534eacd2cd565e40a980f66f..ff0249303d58258d866351039d0b9fb74303b5b4 100644 (file)
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -60,7 +60,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %right T_YIELD
 %right T_DOUBLE_ARROW
 %right T_YIELD_FROM
-%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL
+%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL T_COALESCE_EQUAL
 %left '?' ':'
 %right T_COALESCE
 %left T_BOOLEAN_OR
@@ -118,6 +118,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token T_XOR_EQUAL    "^= (T_XOR_EQUAL)"
 %token T_SL_EQUAL     "<<= (T_SL_EQUAL)"
 %token T_SR_EQUAL     ">>= (T_SR_EQUAL)"
+%token T_COALESCE_EQUAL "??= (T_COALESCE_EQUAL)"
 %token T_BOOLEAN_OR   "|| (T_BOOLEAN_OR)"
 %token T_BOOLEAN_AND  "&& (T_BOOLEAN_AND)"
 %token T_IS_EQUAL     "== (T_IS_EQUAL)"
@@ -906,6 +907,8 @@ expr:
                        { $$ = zend_ast_create_assign_op(ZEND_ASSIGN_SL, $1, $3); }
        |       variable T_SR_EQUAL expr
                        { $$ = zend_ast_create_assign_op(ZEND_ASSIGN_SR, $1, $3); }
+       |       variable T_COALESCE_EQUAL expr
+                       { $$ = zend_ast_create(ZEND_AST_ASSIGN_COALESCE, $1, $3); }
        |       variable T_INC { $$ = zend_ast_create(ZEND_AST_POST_INC, $1); }
        |       T_INC variable { $$ = zend_ast_create(ZEND_AST_PRE_INC, $2); }
        |       variable T_DEC { $$ = zend_ast_create(ZEND_AST_POST_DEC, $1); }

diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 9fd8d04dd11bc55cd06a3be75b398c6cd079911b..bf3e503b7aa652e7d2362a423f31f7946ce449c4 100644 (file)
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -1681,6 +1681,10 @@ NEWLINE ("\r"|"\n"|"\r\n")
        RETURN_TOKEN(T_XOR_EQUAL);
 }
 
+<ST_IN_SCRIPTING>"??=" {
+       RETURN_TOKEN(T_COALESCE_EQUAL);
+}
+
 <ST_IN_SCRIPTING>"||" {
        RETURN_TOKEN(T_BOOLEAN_OR);
 }

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 7bffed760ce614da027b40bc430f87ac71288cca..fea6369e50c4f911833680f960e553f6b7af3308 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -547,12 +547,27 @@ static uint32_t zend_get_brk_cont_target(const zend_op_array *op_array, const ze
        return opline->opcode == ZEND_BRK ? jmp_to->brk : jmp_to->cont;
 }
 
+static void emit_live_range_raw(
+               zend_op_array *op_array, uint32_t var_num, uint32_t kind, uint32_t start, uint32_t end) {
+       zend_live_range *range;
+
+       op_array->last_live_range++;
+       op_array->live_range = erealloc(op_array->live_range,
+               sizeof(zend_live_range) * op_array->last_live_range);
+
+       ZEND_ASSERT(start < end);
+       range = &op_array->live_range[op_array->last_live_range - 1];
+       range->var = (uint32_t) (intptr_t) ZEND_CALL_VAR_NUM(NULL, op_array->last_var + var_num);
+       range->var |= kind;
+       range->start = start;
+       range->end = end;
+}
+
 static void emit_live_range(
                zend_op_array *op_array, uint32_t var_num, uint32_t start, uint32_t end,
                zend_needs_live_range_cb needs_live_range) {
        zend_op *def_opline = &op_array->opcodes[start], *orig_def_opline = def_opline;
        zend_op *use_opline = &op_array->opcodes[end];
-       zend_live_range *range;
        uint32_t kind;
 
        switch (def_opline->opcode) {
@@ -589,7 +604,8 @@ static void emit_live_range(
                        break;
                /* Objects created via ZEND_NEW are only fully initialized
                 * after the DO_FCALL (constructor call). */
-               case ZEND_NEW: {
+               case ZEND_NEW:
+               {
                        int level = 0;
                        while (def_opline + 1 < use_opline) {
                                def_opline++;
@@ -629,6 +645,41 @@ static void emit_live_range(
                        kind = ZEND_LIVE_TMPVAR;
                        break;
                }
+               case ZEND_COPY_TMP:
+               {
+                       /* COPY_TMP has a split live-range: One from the definition until the use in
+                        * "null" branch, and another from the start of the "non-null" branch to the
+                        * FREE opcode. */
+                       uint32_t rt_var_num =
+                               (uint32_t) (intptr_t) ZEND_CALL_VAR_NUM(NULL, op_array->last_var + var_num);
+                       zend_op *block_start_op = use_opline;
+
+                       if (needs_live_range && !needs_live_range(op_array, orig_def_opline)) {
+                               return;
+                       }
+
+                       while ((block_start_op-1)->opcode == ZEND_FREE) {
+                               block_start_op--;
+                       }
+
+                       kind = ZEND_LIVE_TMPVAR;
+                       start = block_start_op - op_array->opcodes;
+                       if (start != end) {
+                               emit_live_range_raw(op_array, var_num, kind, start, end);
+                       }
+
+                       do {
+                               use_opline--;
+                       } while (!(
+                               ((use_opline->op1_type & (IS_TMP_VAR|IS_VAR)) && use_opline->op1.var == rt_var_num) ||
+                               ((use_opline->op2_type & (IS_TMP_VAR|IS_VAR)) && use_opline->op2.var == rt_var_num)
+                       ));
+
+                       start = def_opline + 1 - op_array->opcodes;
+                       end = use_opline - op_array->opcodes;
+                       emit_live_range_raw(op_array, var_num, kind, start, end);
+                       return;
+               }
        }
 
        /* Check hook to determine whether a live range is necessary, e.g. based on type info. */
@@ -636,16 +687,7 @@ static void emit_live_range(
                return;
        }
 
-       op_array->last_live_range++;
-       op_array->live_range = erealloc(op_array->live_range,
-               sizeof(zend_live_range) * op_array->last_live_range);
-
-       ZEND_ASSERT(start < end);
-       range = &op_array->live_range[op_array->last_live_range - 1];
-       range->var = (uint32_t) (intptr_t) ZEND_CALL_VAR_NUM(NULL, op_array->last_var + var_num);
-       range->var |= kind;
-       range->start = start;
-       range->end = end;
+       emit_live_range_raw(op_array, var_num, kind, start, end);
 }
 
 static zend_bool is_fake_def(zend_op *opline) {
@@ -659,7 +701,8 @@ static zend_bool keeps_op1_alive(zend_op *opline) {
         * it is later freed by something else. */
        if (opline->opcode == ZEND_CASE
         || opline->opcode == ZEND_SWITCH_LONG
-        || opline->opcode == ZEND_FETCH_LIST_R) {
+        || opline->opcode == ZEND_FETCH_LIST_R
+        || opline->opcode == ZEND_COPY_TMP) {
                return 1;
        }
        ZEND_ASSERT(opline->opcode != ZEND_SWITCH_STRING

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index ed62b123cf682470b24f5ba8f6c1b69b49c7215b..e03133d2da8b0a007e0b91c01e4dc9716bd05330 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -8449,6 +8449,16 @@ ZEND_VM_HANDLER(195, ZEND_FUNC_GET_ARGS, UNUSED|CONST, UNUSED)
        ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(207, ZEND_COPY_TMP, TMPVAR, UNUSED)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
+       zval *result = EX_VAR(opline->result.var);
+       ZVAL_COPY(result, value);
+       ZEND_VM_NEXT_OPCODE();
+}
+
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_JMP, (OP_JMP_ADDR(op, op->op1) > op), ZEND_JMP_FORWARD, JMP_ADDR, ANY)
 {
        USE_OPLINE

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index ed6f2ed0f73815a33f520d8d2d96e173e01de473..e00beafc255ffdd979cf782999e1e4e2142d9e19 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -17876,6 +17876,16 @@ try_instanceof:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       zval *result = EX_VAR(opline->result.var);
+       ZVAL_COPY(result, value);
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -60454,6 +60464,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_LABEL,
                        (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -63666,6 +63677,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
                                ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
+                               ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ADD_SPEC_TMPVAR_CV):
                                VM_TRACE(ZEND_ADD_SPEC_TMPVAR_CV)
                                ZEND_ADD_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -71657,6 +71672,7 @@ void zend_vm_init(void)
                ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER,
                ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
                ZEND_JMP_FORWARD_SPEC_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -72697,9 +72713,9 @@ void zend_vm_init(void)
                2705,
                2706 | SPEC_RULE_OP1,
                2711,
-               4616,
+               4617,
                2712,
-               4616,
+               4617,
                2713 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
                2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2863,
@@ -72707,8 +72723,8 @@ void zend_vm_init(void)
                2865,
                2866 | SPEC_RULE_OP1,
                2871,
-               4616,
-               4616,
+               4617,
+               4617,
                2872,
                2873,
                2874,
@@ -72760,7 +72776,8 @@ void zend_vm_init(void)
                3648 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3673 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3698 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4616
+               3723,
+               4617
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -72965,7 +72982,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3724 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3725 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -72973,7 +72990,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3749 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3750 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -72981,7 +72998,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3774 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3775 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -72992,17 +73009,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3799 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3800 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3824 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3825 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3849 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3850 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -73013,17 +73030,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3874 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3875 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3899 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3900 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3924 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3925 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_EQUAL:
@@ -73034,12 +73051,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3949 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3950 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4024 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4025 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_NOT_EQUAL:
@@ -73050,12 +73067,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4099 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4100 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4174 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4175 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_SMALLER:
@@ -73063,12 +73080,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4249 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4250 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4324 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4325 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -73076,75 +73093,75 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4399 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4400 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4474 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4475 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 4567 | SPEC_RULE_OP1;
+                               spec = 4568 | SPEC_RULE_OP1;
                        } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) {
-                               spec = 4572 | SPEC_RULE_OP1;
+                               spec = 4573 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4549 | SPEC_RULE_RETVAL;
+                               spec = 4550 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4551 | SPEC_RULE_RETVAL;
+                               spec = 4552 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4553 | SPEC_RULE_RETVAL;
+                               spec = 4554 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4555 | SPEC_RULE_RETVAL;
+                               spec = 4556 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4557 | SPEC_RULE_RETVAL;
+                               spec = 4558 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4559 | SPEC_RULE_RETVAL;
+                               spec = 4560 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4561;
-                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4562;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4563;
+                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                               spec = 4564;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4564;
-                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4565;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4566;
+                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                               spec = 4567;
                        }
                        break;
                case ZEND_JMP:
                        if (OP_JMP_ADDR(op, op->op1) > op) {
-                               spec = 3723;
+                               spec = 3724;
                        }
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 4612;
+                               spec = 4613;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4607 | SPEC_RULE_OP1;
+                               spec = 4608 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_FE_FETCH_R:
                        if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
-                               spec = 4614 | SPEC_RULE_RETVAL;
+                               spec = 4615 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -73152,17 +73169,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4577 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4578 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_SEND_VAL_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 4613;
+                               spec = 4614;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4602 | SPEC_RULE_OP1;
+                               spec = 4603 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 93e0c6ffeb76e0b50a8dfd3aab6d28440843076f..4dd164f17c182715cf8496e89d120fba54dbfdac 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1901,495 +1901,496 @@
        _(3718, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \
        _(3720, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \
        _(3721, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
-       _(3723, ZEND_JMP_FORWARD_SPEC) \
-       _(3729, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3730, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3723, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
+       _(3724, ZEND_JMP_FORWARD_SPEC) \
+       _(3730, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3731, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3733, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3734, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3735, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3732, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3734, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3735, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3736, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3738, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3744, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3745, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3737, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3739, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3745, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3746, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3748, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3754, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3755, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3747, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3749, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3755, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3756, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3758, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3759, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3760, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3757, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3759, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3760, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3761, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3763, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3769, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3770, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3762, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3764, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3770, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3771, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3773, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3779, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3780, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3772, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3774, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3780, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3781, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3783, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3784, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3785, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3782, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3784, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3785, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3786, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3788, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3794, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3795, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3787, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3789, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3795, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3796, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3798, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3800, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3797, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3799, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3801, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3803, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3804, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3805, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3802, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3804, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3805, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3806, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3808, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3809, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3810, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3807, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3809, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3810, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3811, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3813, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3819, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3820, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3812, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3814, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3820, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3821, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3823, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3825, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3822, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3824, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3826, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3828, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3829, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3830, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3827, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3829, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3830, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3831, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3833, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3834, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3835, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3832, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3834, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3835, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3836, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3838, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3844, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3845, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3837, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3839, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3845, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3846, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3848, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3850, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3847, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3849, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3851, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3853, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3854, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3855, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3852, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3854, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3855, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3856, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3858, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3859, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3860, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3857, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3859, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3860, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3861, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3863, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3869, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3870, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3862, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3864, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3870, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3871, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3873, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3879, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3880, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3872, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3874, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3880, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3881, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3883, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3884, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3885, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3882, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3884, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3885, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3886, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3888, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3894, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3895, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3887, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3889, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3895, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3896, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3898, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3904, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3905, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3897, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3899, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3905, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3906, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3908, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3909, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3910, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3907, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3909, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3910, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3911, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3913, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3919, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3920, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3912, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3914, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3920, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3921, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3923, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3929, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3930, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3922, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3924, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3930, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3931, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3933, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3934, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3935, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3932, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3934, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3935, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3936, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3938, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3944, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3945, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3937, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3939, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3945, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3946, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3948, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3964, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3965, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3966, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3967, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3968, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3969, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3970, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3971, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3972, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3976, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3977, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3978, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3979, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3980, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3981, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3982, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3983, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3984, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3985, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3986, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3987, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3991, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3992, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3993, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4009, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4010, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4011, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4012, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4013, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4014, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4015, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4016, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4017, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4021, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4022, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4023, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4039, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4040, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4041, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4042, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4043, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4044, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4045, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4046, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4047, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4051, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4052, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4053, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4054, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4055, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4056, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4057, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4058, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4059, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4060, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4061, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4062, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4066, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4067, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4068, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4084, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4085, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4086, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4087, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4088, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4089, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4090, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4091, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4092, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4096, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4097, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4098, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4114, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4115, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4116, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4117, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4118, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4119, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4120, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4121, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4122, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4126, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4127, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4128, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4129, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4130, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4131, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4132, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4133, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4134, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4135, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4136, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4137, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4141, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4142, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4143, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4159, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4160, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4161, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4162, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4163, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4164, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4165, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4166, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4167, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4171, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4172, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4173, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4189, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4190, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4191, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4192, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4193, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4194, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4195, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4196, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4197, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4201, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4202, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4209, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4210, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4211, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4216, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4217, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4234, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4235, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4236, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4237, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4238, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4239, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4240, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4241, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4242, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4246, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4247, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4252, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4253, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4254, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4255, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4256, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4257, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4261, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4262, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4263, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4264, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4265, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4266, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4267, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4268, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4269, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4270, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4271, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4272, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4276, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4277, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4278, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4279, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4280, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4281, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4282, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4283, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4284, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4291, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4292, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4309, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4310, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4311, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4315, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4316, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4317, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4321, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4322, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4323, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4327, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4328, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4329, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4330, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4331, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4332, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4336, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4337, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4338, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4339, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4340, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4341, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4342, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4343, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4344, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4345, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4346, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4347, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4351, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4352, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4353, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4354, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4355, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4356, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4357, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4358, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4359, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4366, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4367, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4384, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4385, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4386, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4390, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4391, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4392, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4396, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4397, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4398, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4402, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4403, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4404, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4405, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4406, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4407, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4411, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4412, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4413, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4414, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4415, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4416, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4417, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4418, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4419, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4420, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4421, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4422, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4426, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4427, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4429, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4430, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4431, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4441, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4442, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4459, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4460, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4461, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4465, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4466, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4467, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4471, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4472, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4473, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4477, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4478, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4479, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4480, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4481, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4482, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4486, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4487, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4488, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4489, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4490, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4491, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4492, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4493, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4494, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4495, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4496, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4497, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4501, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4502, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4504, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4505, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4506, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4516, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4517, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4534, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4535, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4536, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4540, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4541, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4542, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4546, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4547, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4548, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4549, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4550, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4551, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4552, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4553, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4554, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4555, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4556, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4557, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4558, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4559, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4560, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4561, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(4562, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
-       _(4563, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(4564, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(4565, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
-       _(4566, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(4567, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(4568, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3947, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3949, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3965, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3966, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3967, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3968, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3969, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3970, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3971, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3972, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3973, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3977, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3978, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3979, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3980, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3981, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3982, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3983, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3984, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3985, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3986, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3987, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3988, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3992, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3993, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3994, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4010, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4011, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4012, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4013, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4014, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4015, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4016, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4017, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4018, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4022, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4023, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4024, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4040, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4041, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4042, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4043, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4044, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4045, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4046, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4047, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4048, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4052, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4053, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4054, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4055, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4056, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4057, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4058, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4059, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4060, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4061, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4062, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4063, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4067, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4068, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4069, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4085, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4086, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4087, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4088, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4089, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4090, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4091, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4092, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4093, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4097, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4098, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4099, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4115, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4116, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4117, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4118, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4119, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4120, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4121, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4122, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4123, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4127, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4128, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4129, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4130, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4131, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4132, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4133, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4134, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4135, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4136, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4137, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4138, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4142, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4143, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4144, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4160, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4161, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4162, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4163, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4164, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4165, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4166, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4167, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4168, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4172, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4173, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4174, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4190, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4191, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4192, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4193, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4194, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4195, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4196, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4197, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4198, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4202, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4209, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4210, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4211, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4213, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4217, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4219, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4235, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4236, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4237, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4238, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4239, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4240, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4241, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4242, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4243, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4247, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4249, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4253, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4254, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4255, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4256, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4257, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4258, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4262, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4263, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4264, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4265, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4266, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4267, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4268, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4269, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4270, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4271, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4272, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4273, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4277, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4278, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4279, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4280, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4281, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4282, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4283, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4284, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4288, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4292, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4294, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4310, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4311, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4315, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4316, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4317, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4318, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4322, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4323, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4324, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4328, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4329, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4330, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4331, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4332, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4333, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4337, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4338, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4339, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4340, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4341, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4342, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4343, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4344, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4345, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4346, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4347, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4348, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4352, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4353, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4354, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4355, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4356, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4357, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4358, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4359, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4363, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4367, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4369, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4385, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4386, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4390, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4391, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4392, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4393, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4397, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4398, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4399, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4403, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4404, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4405, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4406, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4407, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4408, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4412, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4413, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4414, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4415, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4416, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4417, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4418, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4419, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4420, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4421, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4422, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4423, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4427, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4429, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4430, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4431, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4438, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4442, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4444, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4460, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4461, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4465, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4466, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4467, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4468, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4472, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4473, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4474, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4478, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4479, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4480, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4481, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4482, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4483, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4487, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4488, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4489, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4490, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4491, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4492, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4493, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4494, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4495, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4496, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4497, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4498, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4502, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4504, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4505, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4506, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4513, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4517, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4519, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4535, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4536, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4540, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4541, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4542, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4543, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4547, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4548, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4549, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4550, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4551, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4552, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4553, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4554, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4555, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4556, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4557, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4558, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4559, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4560, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4561, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4562, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4563, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+       _(4564, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4565, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4566, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+       _(4567, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4568, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
        _(4569, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(4571, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(4572, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(4573, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4570, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4572, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4573, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
        _(4574, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(4576, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(4578, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4575, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4577, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
        _(4579, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(4581, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(4582, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(4583, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4580, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4582, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4583, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
        _(4584, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4586, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4587, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(4588, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4585, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4587, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4588, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
        _(4589, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4591, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4597, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(4598, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4590, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4592, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4598, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
        _(4599, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(4601, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(4604, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(4606, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(4609, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(4611, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(4612, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(4613, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(4614, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(4615, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(4615+1, ZEND_NULL)
+       _(4600, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4602, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4605, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(4607, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(4610, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(4612, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(4613, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(4614, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(4615, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(4616, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(4616+1, ZEND_NULL)

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index b821fcbc8f490c71034443516d5facbd9ca82276..871f16176faa30520a6cbf80875edfe8120a35c2 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[207] = {
+static const char *zend_vm_opcodes_names[208] = {
        "ZEND_NOP",
        "ZEND_ADD",
        "ZEND_SUB",
@@ -230,9 +230,10 @@ static const char *zend_vm_opcodes_names[207] = {
        "ZEND_PRE_DEC_STATIC_PROP",
        "ZEND_POST_INC_STATIC_PROP",
        "ZEND_POST_DEC_STATIC_PROP",
+       "ZEND_COPY_TMP",
 };
 
-static uint32_t zend_vm_opcodes_flags[207] = {
+static uint32_t zend_vm_opcodes_flags[208] = {
        0x00000000,
        0x00000707,
        0x00000707,
@@ -440,6 +441,7 @@ static uint32_t zend_vm_opcodes_flags[207] = {
        0x00040307,
        0x00040307,
        0x00040307,
+       0x00000105,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) {

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index c4c9c1c58302e694c81d54cf05f3ab7df1a18142..78d2acc46d4320eacec4dffb974cd05b076f0f7f 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -279,7 +279,8 @@ END_EXTERN_C()
 #define ZEND_PRE_DEC_STATIC_PROP             204
 #define ZEND_POST_INC_STATIC_PROP            205
 #define ZEND_POST_DEC_STATIC_PROP            206
+#define ZEND_COPY_TMP                        207
 
-#define ZEND_VM_LAST_OPCODE                  206
+#define ZEND_VM_LAST_OPCODE                  207
 
 #endif

diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index 5aa32bfe034873f069bc9a4ad38927db3f2f6f7a..45fe55b1ed595819271c39f5e6a36a07b5f7f68f 100644 (file)
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -452,8 +452,9 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array
                                break;
 
                        case ZEND_CASE:
+                       case ZEND_COPY_TMP:
                                if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
-                                       /* CASE variable will be deleted later by FREE, so we can't optimize it */
+                                       /* Variable will be deleted later by FREE, so we can't optimize it */
                                        Tsource[VAR_NUM(opline->op1.var)] = NULL;
                                        break;
                                }

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 34e9dcd0510825ebf84c3baf6e01b0173ec842bc..0eb042f5f266933229b81548923c0f8f5001a533 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -1680,6 +1680,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                case ZEND_QM_ASSIGN:
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
+               case ZEND_COPY_TMP:
                        SET_RESULT(result, op1);
                        break;
 #if 0

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 980f3c5fea27f33858dc54c033eebde72a77bc80..d9e882c5b9f7cf8a3834f7e023b6b656a94faaf8 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -1208,6 +1208,7 @@ int zend_inference_calc_range(const zend_op_array *op_array, zend_ssa *ssa, int
                case ZEND_QM_ASSIGN:
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
+               case ZEND_COPY_TMP:
                        if (ssa->ops[line].op1_def == var) {
                                if (ssa->ops[line].op1_def >= 0) {
                                        if (OP1_HAS_RANGE()) {
@@ -2554,6 +2555,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                case ZEND_QM_ASSIGN:
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
+               case ZEND_COPY_TMP:
                        if (ssa_ops[i].op1_def >= 0) {
                                tmp = t1;
                                if ((t1 & (MAY_BE_RC1|MAY_BE_REF)) && (opline->op1_type == IS_CV)) {
@@ -4458,6 +4460,7 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                case ZEND_ISSET_ISEMPTY_CV:
                case ZEND_FUNC_NUM_ARGS:
                case ZEND_FUNC_GET_ARGS:
+               case ZEND_COPY_TMP:
                        return 0;
                case ZEND_INIT_FCALL:
                        /* can't throw, because call is resolved at compile time */

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 096668ee0f1158f69a7dad098a0e183befd98704..22868a4c21be56b725d81fe6b0c5a30672ec0c64 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -371,6 +371,7 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
                        return 0;
                case ZEND_CASE:
                case ZEND_FETCH_LIST_R:
+               case ZEND_COPY_TMP:
                        return 0;
                case ZEND_CONCAT:
                case ZEND_FAST_CONCAT:

diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index 3ffef8a55d759d2001548dfba88bb396b410230d..474c08be2fc63981edeb631b3eb5033063418ce7 100644 (file)
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -51,6 +51,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) {
        REGISTER_LONG_CONSTANT("T_SL_EQUAL", T_SL_EQUAL, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_SR_EQUAL", T_SR_EQUAL, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_POW_EQUAL", T_POW_EQUAL, CONST_CS | CONST_PERSISTENT);
+       REGISTER_LONG_CONSTANT("T_COALESCE_EQUAL", T_COALESCE_EQUAL, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_COALESCE", T_COALESCE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_BOOLEAN_OR", T_BOOLEAN_OR, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_BOOLEAN_AND", T_BOOLEAN_AND, CONST_CS | CONST_PERSISTENT);
@@ -191,6 +192,7 @@ char *get_token_type_name(int token_type)
                case T_SL_EQUAL: return "T_SL_EQUAL";
                case T_SR_EQUAL: return "T_SR_EQUAL";
                case T_POW_EQUAL: return "T_POW_EQUAL";
+               case T_COALESCE_EQUAL: return "T_COALESCE_EQUAL";
                case T_COALESCE: return "T_COALESCE";
                case T_BOOLEAN_OR: return "T_BOOLEAN_OR";
                case T_BOOLEAN_AND: return "T_BOOLEAN_AND";
@@ -304,3 +306,4 @@ char *get_token_type_name(int token_type)
        }
        return "UNKNOWN";
 }
+