Replace zend_class_entry->traits by persistent zend_class_entry->trait_names.

Move trait binding code into ZEND_DECLARE_*CLASS opcodes.
Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.

diff --git a/Zend/zend.h b/Zend/zend.h
index d303e4c0e54bf76c08373a51aeec2154b40c4a2d..b1f38fc0eac7b4a5bbeaab254bd467c5fcb20c6c 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -82,6 +82,11 @@ struct _zend_unserialize_data;
 typedef struct _zend_serialize_data zend_serialize_data;
 typedef struct _zend_unserialize_data zend_unserialize_data;
 
+typedef struct _zend_class_name {
+       zend_string *name;
+       zend_string *lc_name;
+} zend_class_name;
+
 typedef struct _zend_trait_method_reference {
        zend_string *method_name;
        zend_string *class_name;
@@ -156,7 +161,7 @@ struct _zend_class_entry {
        uint32_t num_traits;
        zend_class_entry **interfaces;
 
-       zend_class_entry **traits;
+       zend_class_name *trait_names;
        zend_trait_alias **trait_aliases;
        zend_trait_precedence **trait_precedences;
 

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index de48b526bcdf1a227ffaab893afec29ce9c2ef99..ab25e4960343f74a9acdbd30a109b7b7f562946f 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -213,7 +213,7 @@ typedef struct _zend_fcall_info_cache {
                class_container.unserialize_func = NULL;                                \
                class_container.parent = NULL;                                                  \
                class_container.num_interfaces = 0;                                             \
-               class_container.traits = NULL;                                                  \
+               class_container.trait_names = NULL;                                             \
                class_container.num_traits = 0;                                                 \
                class_container.trait_aliases = NULL;                                   \
                class_container.trait_precedences = NULL;                               \

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 176d10c76d055f5a676f70e931e60f0ba869f981..540c0f4b9a210eb35bf67335e47e8c011bc7a4e6 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1031,19 +1031,12 @@ ZEND_API void function_add_ref(zend_function *function) /* {{{ */
 }
 /* }}} */
 
-ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */
+static zend_always_inline int do_bind_function_ex(zval *lcname, HashTable *function_table, zend_bool compile_time) /* {{{ */
 {
        zend_function *function, *new_function;
-       zval *lcname, *rtd_key, *zv;
-
-       if (compile_time) {
-               lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
-               rtd_key = lcname + 1;
-       } else {
-               lcname = RT_CONSTANT(opline, opline->op1);
-               rtd_key = lcname + 1;
-       }
+       zval *rtd_key, *zv;
 
+       rtd_key = lcname + 1;
        zv = zend_hash_find_ex(function_table, Z_STR_P(rtd_key), 1);
        function = (zend_function*)Z_PTR_P(zv);
        new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
@@ -1077,21 +1070,33 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opli
 }
 /* }}} */
 
-ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time) /* {{{ */
+ZEND_API int do_bind_function(zval *lcname) /* {{{ */
+{
+       return do_bind_function_ex(lcname, EG(function_table), 0);
+}
+/* }}} */
+
+static int do_early_bind_function(zval *lcname) /* {{{ */
+{
+       return do_bind_function_ex(lcname, CG(function_table), 1);
+}
+/* }}} */
+
+static zend_always_inline zend_class_entry *do_bind_class_ex(zval *lcname, HashTable *class_table, zend_bool compile_time) /* {{{ */
 {
        zend_class_entry *ce;
-       zval *lcname, *rtd_key, *zv;
+       zval *rtd_key, *zv;
 
-       if (compile_time) {
-               lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
-               rtd_key = lcname + 1;
-       } else {
-               lcname = RT_CONSTANT(opline, opline->op1);
-               rtd_key = lcname + 1;
-       }
+       rtd_key = lcname + 1;
        zv = zend_hash_find_ex(class_table, Z_STR_P(rtd_key), 1);
        ZEND_ASSERT(zv);
        ce = (zend_class_entry*)Z_PTR_P(zv);
+
+       if (compile_time && (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
+               /* We currently don't early-bind classes that use traits */
+               return NULL;
+       }
+
        ce->refcount++;
        if (zend_hash_add_ptr(class_table, Z_STR_P(lcname), ce) == NULL) {
                ce->refcount--;
@@ -1105,7 +1110,9 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
                }
                return NULL;
        } else {
-               if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
+               if (!compile_time && (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
+                       zend_do_bind_traits(ce);
+               } else if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS|ZEND_ACC_IMPLEMENT_INTERFACES))) {
                        zend_verify_abstract_class(ce);
                }
                return ce;
@@ -1113,18 +1120,24 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
 }
 /* }}} */
 
-ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time) /* {{{ */
+ZEND_API zend_class_entry *do_bind_class(zval *lcname) /* {{{ */
+{
+       return do_bind_class_ex(lcname, EG(class_table), 0);
+}
+/* }}} */
+
+static zend_class_entry *do_early_bind_class(zval *lcname) /* {{{ */
+{
+       return do_bind_class_ex(lcname, CG(class_table), 1);
+}
+/* }}} */
+
+static zend_always_inline zend_class_entry *do_bind_inherited_class_ex(zval *lcname, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time) /* {{{ */
 {
        zend_class_entry *ce;
-       zval *lcname, *rtd_key, *zv;
+       zval *rtd_key, *zv;
 
-       if (compile_time) {
-               lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
-               rtd_key = lcname + 1;
-       } else {
-               lcname = RT_CONSTANT(opline, opline->op1);
-               rtd_key = lcname + 1;
-       }
+       rtd_key = lcname + 1;
 
        zv = zend_hash_find_ex(class_table, Z_STR_P(rtd_key), 1);
 
@@ -1135,13 +1148,18 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
                         * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
                         * approach to work.
                         */
-                       zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare  %s, because the name is already in use", zend_get_object_type(Z_OBJCE_P(lcname)));
+                       zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare  %s, because the name is already in use", Z_STRVAL_P(lcname));
                }
                return NULL;
        }
 
        ce = (zend_class_entry*)Z_PTR_P(zv);
 
+       if (compile_time && (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
+               /* We currently don't early-bind classes that use traits */
+               return NULL;
+       }
+
        if (zend_hash_exists(class_table, Z_STR_P(lcname))) {
                zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
        }
@@ -1154,10 +1172,27 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
        if (zend_hash_add_ptr(class_table, Z_STR_P(lcname), ce) == NULL) {
                zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
        }
+
+       if (!compile_time && (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
+               zend_do_bind_traits(ce);
+       }
+
        return ce;
 }
 /* }}} */
 
+ZEND_API zend_class_entry *do_bind_inherited_class(zval *lcname, zend_class_entry *parent_ce) /* {{{ */
+{
+       return do_bind_inherited_class_ex(lcname, EG(class_table), parent_ce, 0);
+}
+/* }}} */
+
+static zend_class_entry *do_early_bind_inherited_class(zval *lcname, zend_class_entry *parent_ce) /* {{{ */
+{
+       return do_bind_inherited_class_ex(lcname, CG(class_table), parent_ce, 1);
+}
+/* }}} */
+
 void zend_do_early_binding(void) /* {{{ */
 {
        zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
@@ -1169,13 +1204,13 @@ void zend_do_early_binding(void) /* {{{ */
 
        switch (opline->opcode) {
                case ZEND_DECLARE_FUNCTION:
-                       if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1) == FAILURE) {
+                       if (do_early_bind_function(CT_CONSTANT_EX(CG(active_op_array), opline->op1.constant)) == FAILURE) {
                                return;
                        }
                        table = CG(function_table);
                        break;
                case ZEND_DECLARE_CLASS:
-                       if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1) == NULL) {
+                       if (do_early_bind_class(CT_CONSTANT_EX(CG(active_op_array), opline->op1.constant)) == NULL) {
                                return;
                        }
                        table = CG(class_table);
@@ -1199,7 +1234,7 @@ void zend_do_early_binding(void) /* {{{ */
                                        }
                                        return;
                                }
-                               if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1) == NULL) {
+                               if (do_early_bind_inherited_class(CT_CONSTANT_EX(CG(active_op_array), opline->op1.constant), ce) == NULL) {
                                        return;
                                }
                                zend_del_literal(CG(active_op_array), opline->op2.constant+1);
@@ -1210,10 +1245,7 @@ void zend_do_early_binding(void) /* {{{ */
                        }
                case ZEND_VERIFY_ABSTRACT_CLASS:
                case ZEND_ADD_INTERFACE:
-               case ZEND_ADD_TRAIT:
-               case ZEND_BIND_TRAITS:
                        /* We currently don't early-bind classes that implement interfaces */
-                       /* Classes with traits are handled exactly the same, no early-bind here */
                        return;
                default:
                        zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
@@ -1290,7 +1322,7 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array, uint3
                        const zend_op *opline = &op_array->opcodes[opline_num];
                        zval *parent_name = RT_CONSTANT(opline, opline->op2);
                        if ((ce = zend_lookup_class_ex(Z_STR_P(parent_name), Z_STR_P(parent_name + 1), 0)) != NULL) {
-                               do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0);
+                               do_bind_inherited_class(RT_CONSTANT(&op_array->opcodes[opline_num], op_array->opcodes[opline_num].op1), ce);
                        }
                        opline_num = op_array->opcodes[opline_num].result.opline_num;
                }
@@ -1754,7 +1786,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
                ce->num_interfaces = 0;
                ce->interfaces = NULL;
                ce->num_traits = 0;
-               ce->traits = NULL;
+               ce->trait_names = NULL;
                ce->trait_aliases = NULL;
                ce->trait_precedences = NULL;
                ce->serialize = NULL;
@@ -2052,8 +2084,6 @@ static void zend_check_live_ranges(zend_op *opline) /* {{{ */
                           opline->opcode == ZEND_NEW ||
                           opline->opcode == ZEND_FETCH_CLASS_CONSTANT ||
                           opline->opcode == ZEND_ADD_INTERFACE ||
-                          opline->opcode == ZEND_ADD_TRAIT ||
-                          opline->opcode == ZEND_BIND_TRAITS ||
                           opline->opcode == ZEND_VERIFY_ABSTRACT_CLASS) {
                        /* classes don't have to be destroyed */
                } else if (opline->opcode == ZEND_FAST_RET) {
@@ -6207,9 +6237,11 @@ void zend_compile_use_trait(zend_ast *ast) /* {{{ */
        zend_ast_list *traits = zend_ast_get_list(ast->child[0]);
        zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
        zend_class_entry *ce = CG(active_class_entry);
-       zend_op *opline;
        uint32_t i;
 
+       ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
+       ce->trait_names = erealloc(ce->trait_names, sizeof(zend_class_name) * (ce->num_traits + traits->children));
+
        for (i = 0; i < traits->children; ++i) {
                zend_ast *trait_ast = traits->child[i];
                zend_string *name = zend_ast_get_str(trait_ast);
@@ -6228,13 +6260,8 @@ void zend_compile_use_trait(zend_ast *ast) /* {{{ */
                                break;
                }
 
-               opline = get_next_op(CG(active_op_array));
-               opline->opcode = ZEND_ADD_TRAIT;
-               SET_NODE(opline->op1, &FC(implementing_class));
-               opline->op2_type = IS_CONST;
-               opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
-                       zend_resolve_class_name_ast(trait_ast));
-
+               ce->trait_names[ce->num_traits].name = zend_resolve_class_name_ast(trait_ast);
+               ce->trait_names[ce->num_traits].lc_name = zend_string_tolower(ce->trait_names[ce->num_traits].name);
                ce->num_traits++;
        }
 
@@ -6431,7 +6458,7 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */
        /* Reset lineno for final opcodes and errors */
        CG(zend_lineno) = ast->lineno;
 
-       if (ce->num_traits == 0) {
+       if (!(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
                /* For traits this check is delayed until after trait binding */
                zend_check_deprecated_constructor(ce);
        }
@@ -6470,28 +6497,16 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */
                }
        }
 
-       /* Check for traits and proceed like with interfaces.
-        * The only difference will be a combined handling of them in the end.
-        * Thus, we need another opcode here. */
-       if (ce->num_traits > 0) {
-               ce->traits = NULL;
-               ce->num_traits = 0;
-               ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
-
-               zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL);
-       }
-
        if (implements_ast) {
                zend_compile_implements(&declare_node, implements_ast);
-       }
-
-       if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
-               && (extends_ast || implements_ast)
-       ) {
-               zend_verify_abstract_class(ce);
-               if (implements_ast) {
+               if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) {
+                       zend_verify_abstract_class(ce);
                        zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL);
                }
+       }  else if (extends_ast) {
+               if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) {
+                       zend_verify_abstract_class(ce);
+               }
        }
 
        /* Inherit interfaces; reset number to zero, we need it for above check and

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 722ad40c1f3ec0db9579ae0b5c49950feeb5c5ca..68add4f1519145df810449e9ea60b697978a984d 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -757,9 +757,9 @@ zend_bool zend_handle_encoding_declaration(zend_ast *ast);
 /* parser-driven code generators */
 void zend_do_free(znode *op1);
 
-ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time);
-ZEND_API zend_class_entry *do_bind_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time);
-ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time);
+ZEND_API int do_bind_function(zval *lcname);
+ZEND_API zend_class_entry *do_bind_class(zval *lcname);
+ZEND_API zend_class_entry *do_bind_inherited_class(zval *lcname, zend_class_entry *parent_ce);
 ZEND_API uint32_t zend_build_delayed_early_binding_list(const zend_op_array *op_array);
 ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array, uint32_t first_early_binding_opline);
 

diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c
index c5bc61d6c5572a5334b98dbf0c3daa44c3b720da..7a02806394c626a824df298de7091a7ea185e7b3 100644 (file)
--- a/Zend/zend_inheritance.c
+++ b/Zend/zend_inheritance.c
@@ -989,7 +989,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 
        if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) {
                ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
-       } else if (!(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
+       } else if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
                /* The verification will be done in runtime by ZEND_VERIFY_ABSTRACT_CLASS */
                zend_verify_abstract_class(ce);
        }
@@ -1084,35 +1084,6 @@ ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry
 }
 /* }}} */
 
-ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait) /* {{{ */
-{
-       uint32_t i, ignore = 0;
-       uint32_t current_trait_num = ce->num_traits;
-       uint32_t parent_trait_num  = ce->parent ? ce->parent->num_traits : 0;
-
-       for (i = 0; i < ce->num_traits; i++) {
-               if (ce->traits[i] == NULL) {
-                       memmove(ce->traits + i, ce->traits + i + 1, sizeof(zend_class_entry*) * (--ce->num_traits - i));
-                       i--;
-               } else if (ce->traits[i] == trait) {
-                       if (i < parent_trait_num) {
-                               ignore = 1;
-                       }
-               }
-       }
-       if (!ignore) {
-               if (ce->num_traits >= current_trait_num) {
-                       if (ce->type == ZEND_INTERNAL_CLASS) {
-                               ce->traits = (zend_class_entry **) realloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
-                       } else {
-                               ce->traits = (zend_class_entry **) erealloc(ce->traits, sizeof(zend_class_entry *) * (++current_trait_num));
-                       }
-               }
-               ce->traits[ce->num_traits++] = trait;
-       }
-}
-/* }}} */
-
 static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_function *other_fn) /* {{{ */
 {
        uint32_t    fn_flags = fn->common.scope->ce_flags;
@@ -1360,7 +1331,7 @@ static int zend_traits_copy_functions(zend_string *fnname, zend_function *fn, ze
 }
 /* }}} */
 
-static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait) /* {{{ */
+static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait, zend_class_entry **traits) /* {{{ */
 {
        uint32_t i;
 
@@ -1370,7 +1341,7 @@ static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *t
        }
 
        for (i = 0; i < ce->num_traits; i++) {
-               if (ce->traits[i] == trait) {
+               if (traits[i] == trait) {
                        return i;
                }
        }
@@ -1379,7 +1350,7 @@ static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *t
 }
 /* }}} */
 
-static void zend_traits_init_trait_structures(zend_class_entry *ce, HashTable ***exclude_tables_ptr, zend_class_entry ***aliases_ptr) /* {{{ */
+static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_entry **traits, HashTable ***exclude_tables_ptr, zend_class_entry ***aliases_ptr) /* {{{ */
 {
        size_t i, j = 0;
        zend_trait_precedence **precedences;
@@ -1405,7 +1376,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, HashTable **
                        if (!trait) {
                                zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
                        }
-                       zend_check_trait_usage(ce, trait);
+                       zend_check_trait_usage(ce, trait, traits);
 
                        /** Ensure that the preferred method is actually available. */
                        lcname = zend_string_tolower(cur_method_ref->method_name);
@@ -1432,7 +1403,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, HashTable **
                                if (!exclude_ce) {
                                        zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(class_name));
                                }
-                               trait_num = zend_check_trait_usage(ce, exclude_ce);
+                               trait_num = zend_check_trait_usage(ce, exclude_ce, traits);
                                if (!exclude_tables[trait_num]) {
                                        ALLOC_HASHTABLE(exclude_tables[trait_num]);
                                        zend_hash_init(exclude_tables[trait_num], 0, NULL, NULL, 0);
@@ -1473,7 +1444,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, HashTable **
                                if (!trait) {
                                        zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
                                }
-                               zend_check_trait_usage(ce, trait);
+                               zend_check_trait_usage(ce, trait, traits);
                                aliases[i] = trait;
 
                                /** And, ensure that the referenced method is resolvable, too. */
@@ -1494,7 +1465,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, HashTable **
 }
 /* }}} */
 
-static void zend_do_traits_method_binding(zend_class_entry *ce, HashTable **exclude_tables, zend_class_entry **aliases) /* {{{ */
+static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry **traits, HashTable **exclude_tables, zend_class_entry **aliases) /* {{{ */
 {
        uint32_t i;
        HashTable *overridden = NULL;
@@ -1503,22 +1474,26 @@ static void zend_do_traits_method_binding(zend_class_entry *ce, HashTable **excl
 
        if (exclude_tables) {
                for (i = 0; i < ce->num_traits; i++) {
-                       /* copies functions, applies defined aliasing, and excludes unused trait methods */
-                       ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
-                               zend_traits_copy_functions(key, fn, ce, &overridden, exclude_tables[i], aliases);
-                       } ZEND_HASH_FOREACH_END();
-
-                       if (exclude_tables[i]) {
-                               zend_hash_destroy(exclude_tables[i]);
-                               FREE_HASHTABLE(exclude_tables[i]);
-                               exclude_tables[i] = NULL;
+                       if (traits[i]) {
+                               /* copies functions, applies defined aliasing, and excludes unused trait methods */
+                               ZEND_HASH_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
+                                       zend_traits_copy_functions(key, fn, ce, &overridden, exclude_tables[i], aliases);
+                               } ZEND_HASH_FOREACH_END();
+
+                               if (exclude_tables[i]) {
+                                       zend_hash_destroy(exclude_tables[i]);
+                                       FREE_HASHTABLE(exclude_tables[i]);
+                                       exclude_tables[i] = NULL;
+                               }
                        }
                }
        } else {
                for (i = 0; i < ce->num_traits; i++) {
-                       ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->traits[i]->function_table, key, fn) {
-                               zend_traits_copy_functions(key, fn, ce, &overridden, NULL, aliases);
-                       } ZEND_HASH_FOREACH_END();
+                       if (traits[i]) {
+                               ZEND_HASH_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
+                                       zend_traits_copy_functions(key, fn, ce, &overridden, NULL, aliases);
+                               } ZEND_HASH_FOREACH_END();
+                       }
                }
        }
 
@@ -1533,14 +1508,15 @@ static void zend_do_traits_method_binding(zend_class_entry *ce, HashTable **excl
 }
 /* }}} */
 
-static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
+static zend_class_entry* find_first_definition(zend_class_entry *ce, zend_class_entry **traits, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
 {
        size_t i;
 
        if (coliding_ce == ce) {
                for (i = 0; i < current_trait; i++) {
-                       if (zend_hash_exists(&ce->traits[i]->properties_info, prop_name)) {
-                               return ce->traits[i];
+                       if (traits[i]
+                        && zend_hash_exists(&traits[i]->properties_info, prop_name)) {
+                               return traits[i];
                        }
                }
        }
@@ -1549,7 +1525,7 @@ static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t curr
 }
 /* }}} */
 
-static void zend_do_traits_property_binding(zend_class_entry *ce) /* {{{ */
+static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_entry **traits) /* {{{ */
 {
        size_t i;
        zend_property_info *property_info;
@@ -1567,7 +1543,10 @@ static void zend_do_traits_property_binding(zend_class_entry *ce) /* {{{ */
         * - if compatible, then strict notice
         */
        for (i = 0; i < ce->num_traits; i++) {
-               ZEND_HASH_FOREACH_PTR(&ce->traits[i]->properties_info, property_info) {
+               if (!traits[i]) {
+                       continue;
+               }
+               ZEND_HASH_FOREACH_PTR(&traits[i]->properties_info, property_info) {
                        /* first get the unmangeld name if necessary,
                         * then check whether the property is already there
                         */
@@ -1604,12 +1583,12 @@ static void zend_do_traits_property_binding(zend_class_entry *ce) /* {{{ */
 
                                                if (flags & ZEND_ACC_STATIC) {
                                                        op1 = &ce->default_static_members_table[coliding_prop->offset];
-                                                       op2 = &ce->traits[i]->default_static_members_table[property_info->offset];
+                                                       op2 = &traits[i]->default_static_members_table[property_info->offset];
                                                        ZVAL_DEINDIRECT(op1);
                                                        ZVAL_DEINDIRECT(op2);
                                                } else {
                                                        op1 = &ce->default_properties_table[OBJ_PROP_TO_NUM(coliding_prop->offset)];
-                                                       op2 = &ce->traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
+                                                       op2 = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
                                                }
 
                                                /* if any of the values is a constant, we try to resolve it */
@@ -1637,7 +1616,7 @@ static void zend_do_traits_property_binding(zend_class_entry *ce) /* {{{ */
                                        if (not_compatible) {
                                                zend_error_noreturn(E_COMPILE_ERROR,
                                                           "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
-                                                               ZSTR_VAL(find_first_definition(ce, i, prop_name, coliding_prop->ce)->name),
+                                                               ZSTR_VAL(find_first_definition(ce, traits, i, prop_name, coliding_prop->ce)->name),
                                                                ZSTR_VAL(property_info->ce->name),
                                                                ZSTR_VAL(prop_name),
                                                                ZSTR_VAL(ce->name));
@@ -1650,10 +1629,10 @@ static void zend_do_traits_property_binding(zend_class_entry *ce) /* {{{ */
 
                        /* property not found, so lets add it */
                        if (flags & ZEND_ACC_STATIC) {
-                               prop_value = &ce->traits[i]->default_static_members_table[property_info->offset];
+                               prop_value = &traits[i]->default_static_members_table[property_info->offset];
                                ZEND_ASSERT(Z_TYPE_P(prop_value) != IS_INDIRECT);
                        } else {
-                               prop_value = &ce->traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
+                               prop_value = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
                        }
 
                        Z_TRY_ADDREF_P(prop_value);
@@ -1721,16 +1700,40 @@ ZEND_API void zend_do_bind_traits(zend_class_entry *ce) /* {{{ */
 {
        HashTable **exclude_tables;
        zend_class_entry **aliases;
+       zend_class_entry **traits, *trait;
+       uint32_t i, j;
 
        if (ce->num_traits == 0) {
                return;
        }
 
+       traits = emalloc(sizeof(zend_class_entry*) * ce->num_traits);
+
+       for (i = 0; i < ce->num_traits; i++) {
+               trait = zend_fetch_class_by_name(ce->trait_names[i].name,
+                       ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT);
+               if (UNEXPECTED(trait == NULL)) {
+                       return;
+               }
+               if (UNEXPECTED(!(trait->ce_flags & ZEND_ACC_TRAIT))) {
+                       zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
+                       return;
+               }
+               for (j = 0; j < i; j++) {
+                       if (traits[j] == trait) {
+                               /* skip duplications */
+                               trait = NULL;
+                               break;
+                       }
+               }
+               traits[i] = trait;
+       }
+
        /* complete initialization of trait strutures in ce */
-       zend_traits_init_trait_structures(ce, &exclude_tables, &aliases);
+       zend_traits_init_trait_structures(ce, traits, &exclude_tables, &aliases);
 
        /* first care about all methods to be flattened into the class */
-       zend_do_traits_method_binding(ce, exclude_tables, aliases);
+       zend_do_traits_method_binding(ce, traits, exclude_tables, aliases);
 
        /* Aliases which have not been applied indicate typos/bugs. */
        zend_do_check_for_inconsistent_traits_aliasing(ce, aliases);
@@ -1744,7 +1747,9 @@ ZEND_API void zend_do_bind_traits(zend_class_entry *ce) /* {{{ */
        }
 
        /* then flatten the properties into it, to, mostly to notfiy developer about problems */
-       zend_do_traits_property_binding(ce);
+       zend_do_traits_property_binding(ce, traits);
+
+       efree(traits);
 
        /* verify that all abstract methods from traits have been implemented */
        zend_verify_abstract_class(ce);

diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h
index cf25516efc84502eaf0b6a64f4a2bcd4f8feeaf8..e655f24160a00489e7d9a992e60274551dfac1df 100644 (file)
--- a/Zend/zend_inheritance.h
+++ b/Zend/zend_inheritance.h
@@ -27,7 +27,6 @@ BEGIN_EXTERN_C()
 ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface);
 ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface);
 
-ZEND_API void zend_do_implement_trait(zend_class_entry *ce, zend_class_entry *trait);
 ZEND_API void zend_do_bind_traits(zend_class_entry *ce);
 
 ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 6bed3c7b59df4c4566126972f84db0f28af8eaaf..a0fd5a71a60599075771954d1e08492d6ce51614 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -158,14 +158,18 @@ ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce)
        }
 }
 
-void _destroy_zend_class_traits_info(zend_class_entry *ce)
+static void _destroy_zend_class_traits_info(zend_class_entry *ce)
 {
-       if (ce->num_traits > 0 && ce->traits) {
-               efree(ce->traits);
+       uint32_t i;
+
+       for (i = 0; i < ce->num_traits; i++) {
+               zend_string_release_ex(ce->trait_names[i].name, 0);
+               zend_string_release_ex(ce->trait_names[i].lc_name, 0);
        }
+       efree(ce->trait_names);
 
        if (ce->trait_aliases) {
-               size_t i = 0;
+               i = 0;
                while (ce->trait_aliases[i]) {
                        if (ce->trait_aliases[i]->trait_method.method_name) {
                                zend_string_release_ex(ce->trait_aliases[i]->trait_method.method_name, 0);
@@ -186,9 +190,9 @@ void _destroy_zend_class_traits_info(zend_class_entry *ce)
        }
 
        if (ce->trait_precedences) {
-               int i = 0;
                int j;
 
+               i = 0;
                while (ce->trait_precedences[i]) {
                        zend_string_release_ex(ce->trait_precedences[i]->trait_method.method_name, 0);
                        zend_string_release_ex(ce->trait_precedences[i]->trait_method.class_name, 0);
@@ -265,7 +269,9 @@ ZEND_API void destroy_zend_class(zval *zv)
                                zend_string_release_ex(ce->info.user.doc_comment, 0);
                        }
 
-                       _destroy_zend_class_traits_info(ce);
+                       if (ce->num_traits > 0) {
+                               _destroy_zend_class_traits_info(ce);
+                       }
 
                        break;
                case ZEND_INTERNAL_CLASS:

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 24859d32965df164c47d77d77cd6a6295f66bdfa..cefecf0e8a9be6bdc2315a2504a1ff816fe063b2 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -6648,7 +6648,7 @@ ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, CONST, ANY)
        USE_OPLINE
 
        SAVE_OPLINE();
-       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(&EX(func)->op_array, opline, EG(class_table), 0);
+       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(RT_CONSTANT(opline, opline->op1));
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -6665,7 +6665,7 @@ ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, CONST, CONST)
                ZEND_ASSERT(EG(exception));
                HANDLE_EXCEPTION();
        }
-       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), parent, 0);
+       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(RT_CONSTANT(opline, opline->op1), parent);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -6686,7 +6686,7 @@ ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, CONST, CONST)
                        ZEND_ASSERT(EG(exception));
                        HANDLE_EXCEPTION();
                }
-               do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), parent, 0);
+               do_bind_inherited_class(RT_CONSTANT(opline, opline->op1), parent);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -6707,8 +6707,9 @@ ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, ANY, ANY, JMP_ADDR)
                ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
                ZEND_VM_CONTINUE();
        }
-
-       if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
+       if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) {
+               zend_do_bind_traits(ce);
+       } else if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS|ZEND_ACC_IMPLEMENT_INTERFACES))) {
                zend_verify_abstract_class(ce);
        }
        ce->ce_flags |= ZEND_ACC_ANON_BOUND;
@@ -6741,6 +6742,9 @@ ZEND_VM_HANDLER(172, ZEND_DECLARE_ANON_INHERITED_CLASS, CONST, CONST, JMP_ADDR)
        }
 
        zend_do_inheritance(ce, parent);
+       if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) {
+               zend_do_bind_traits(ce);
+       }
        ce->ce_flags |= ZEND_ACC_ANON_BOUND;
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -6750,7 +6754,7 @@ ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
        USE_OPLINE
 
        SAVE_OPLINE();
-       do_bind_function(&EX(func)->op_array, opline, EG(function_table), 0);
+       do_bind_function(RT_CONSTANT(opline, opline->op1));
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -6853,39 +6857,6 @@ ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST, CACHE_SLOT)
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY, CACHE_SLOT)
-{
-       USE_OPLINE
-       zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
-       zend_class_entry *trait;
-
-       SAVE_OPLINE();
-       trait = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)),
-                                        Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1),
-                                        ZEND_FETCH_CLASS_TRAIT);
-       if (UNEXPECTED(trait == NULL)) {
-               ZEND_ASSERT(EG(exception));
-               HANDLE_EXCEPTION();
-       }
-       if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
-               zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
-       }
-
-       zend_do_implement_trait(ce, trait);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
-ZEND_VM_HANDLER(155, ZEND_BIND_TRAITS, ANY, ANY)
-{
-       USE_OPLINE
-       zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
-
-       SAVE_OPLINE();
-       zend_do_bind_traits(ce);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_catch_offset, uint32_t op_num)
 {
        /* May be NULL during generator closing (only finally blocks are executed) */

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 20d395a65369c5a55c7bbd51a599c8863475394d..8ae091f5a6b4ef959fa6678f1b52c60f3aab42ca 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1600,8 +1600,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLE
                ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
                ZEND_VM_CONTINUE();
        }
-
-       if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
+       if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) {
+               zend_do_bind_traits(ce);
+       } else if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS|ZEND_ACC_IMPLEMENT_INTERFACES))) {
                zend_verify_abstract_class(ce);
        }
        ce->ce_flags |= ZEND_ACC_ANON_BOUND;
@@ -1613,7 +1614,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(
        USE_OPLINE
 
        SAVE_OPLINE();
-       do_bind_function(&EX(func)->op_array, opline, EG(function_table), 0);
+       do_bind_function(RT_CONSTANT(opline, opline->op1));
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -1646,39 +1647,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(Z
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
-       zend_class_entry *trait;
-
-       SAVE_OPLINE();
-       trait = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)),
-                                        Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1),
-                                        ZEND_FETCH_CLASS_TRAIT);
-       if (UNEXPECTED(trait == NULL)) {
-               ZEND_ASSERT(EG(exception));
-               HANDLE_EXCEPTION();
-       }
-       if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
-               zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
-       }
-
-       zend_do_implement_trait(ce, trait);
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
-
-       SAVE_OPLINE();
-       zend_do_bind_traits(ce);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset, uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        /* May be NULL during generator closing (only finally blocks are executed) */
@@ -3619,7 +3587,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDL
        USE_OPLINE
 
        SAVE_OPLINE();
-       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(&EX(func)->op_array, opline, EG(class_table), 0);
+       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(RT_CONSTANT(opline, opline->op1));
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -5842,7 +5810,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_C
                ZEND_ASSERT(EG(exception));
                HANDLE_EXCEPTION();
        }
-       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), parent, 0);
+       Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(RT_CONSTANT(opline, opline->op1), parent);
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -5863,7 +5831,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYE
                        ZEND_ASSERT(EG(exception));
                        HANDLE_EXCEPTION();
                }
-               do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), parent, 0);
+               do_bind_inherited_class(RT_CONSTANT(opline, opline->op1), parent);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -5894,6 +5862,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_INHERITED_CLASS_S
        }
 
        zend_do_inheritance(ce, parent);
+       if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) {
+               zend_do_bind_traits(ce);
+       }
        ce->ce_flags |= ZEND_ACC_ANON_BOUND;
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -53942,8 +53913,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
                        (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_LABEL,
-                       (void*)&&ZEND_ADD_TRAIT_SPEC_LABEL,
-                       (void*)&&ZEND_BIND_TRAITS_SPEC_LABEL,
                        (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
                        (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
                        (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
@@ -55492,14 +55461,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_NOP_SPEC)
                                ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_ADD_TRAIT_SPEC):
-                               VM_TRACE(ZEND_ADD_TRAIT_SPEC)
-                               ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_BIND_TRAITS_SPEC):
-                               VM_TRACE(ZEND_BIND_TRAITS_SPEC)
-                               ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
                                VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
                                ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63441,8 +63402,6 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_JMP_SET_SPEC_CV_HANDLER,
                ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER,
-               ZEND_ADD_TRAIT_SPEC_HANDLER,
-               ZEND_BIND_TRAITS_SPEC_HANDLER,
                ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
                ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
                ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
@@ -64919,52 +64878,52 @@ void zend_vm_init(void)
                2592,
                2593 | SPEC_RULE_OP1,
                2598,
+               3918,
+               3918,
                2599,
                2600,
                2601,
                2602,
-               2603,
-               2604,
-               2605 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2630 | SPEC_RULE_OP1,
+               2603 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2628 | SPEC_RULE_OP1,
+               2633,
+               2634,
                2635,
                2636,
-               2637,
-               2638,
-               2639 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2664 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               2739,
-               2740 | SPEC_RULE_OP1,
-               2745 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2770,
-               2771,
-               2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2847 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2872 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2922 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2947 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2972 | SPEC_RULE_OP1,
+               2637 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               2737,
+               2738 | SPEC_RULE_OP1,
+               2743 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2768,
+               2769,
+               2770 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2795 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2820 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2845 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2870 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2895 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2920 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2945 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2970 | SPEC_RULE_OP1,
+               2975,
+               2976,
                2977,
                2978,
                2979,
-               2980,
-               2981,
-               2982 | SPEC_RULE_OP1,
-               2987 | SPEC_RULE_OP1,
-               2992 | SPEC_RULE_OP1,
-               2997 | SPEC_RULE_OP1,
-               3002 | SPEC_RULE_OP1,
-               3007,
-               3008 | SPEC_RULE_OP1,
-               3013,
-               3014 | SPEC_RULE_OP1,
-               3019,
-               3020 | SPEC_RULE_ISSET,
-               3022 | SPEC_RULE_OP2,
-               3920
+               2980 | SPEC_RULE_OP1,
+               2985 | SPEC_RULE_OP1,
+               2990 | SPEC_RULE_OP1,
+               2995 | SPEC_RULE_OP1,
+               3000 | SPEC_RULE_OP1,
+               3005,
+               3006 | SPEC_RULE_OP1,
+               3011,
+               3012 | SPEC_RULE_OP1,
+               3017,
+               3018 | SPEC_RULE_ISSET,
+               3020 | SPEC_RULE_OP2,
+               3918
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -65165,7 +65124,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 = 3028 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3026 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65173,7 +65132,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 = 3053 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3051 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65181,7 +65140,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 = 3078 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3076 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65192,17 +65151,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 = 3103 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3101 | 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 = 3128 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3126 | 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 = 3153 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3151 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -65213,17 +65172,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 = 3178 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3176 | 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 = 3203 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3201 | 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 = 3228 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_EQUAL:
@@ -65234,12 +65193,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 = 3253 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3251 | 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 = 3328 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3326 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_NOT_EQUAL:
@@ -65250,12 +65209,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 = 3403 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3401 | 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 = 3478 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3476 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_SMALLER:
@@ -65263,12 +65222,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 = 3553 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3551 | 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 = 3628 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3626 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -65276,75 +65235,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 = 3703 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3701 | 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 = 3778 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3776 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 3871 | SPEC_RULE_OP1;
+                               spec = 3869 | 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 = 3876 | SPEC_RULE_OP1;
+                               spec = 3874 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3853 | SPEC_RULE_RETVAL;
+                               spec = 3851 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3855 | SPEC_RULE_RETVAL;
+                               spec = 3853 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3857 | SPEC_RULE_RETVAL;
+                               spec = 3855 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3859 | SPEC_RULE_RETVAL;
+                               spec = 3857 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3861 | SPEC_RULE_RETVAL;
+                               spec = 3859 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3863 | SPEC_RULE_RETVAL;
+                               spec = 3861 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3865;
+                               spec = 3863;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3866;
+                               spec = 3864;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3867;
+                               spec = 3865;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3868;
+                               spec = 3866;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3869;
+                               spec = 3867;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3870;
+                               spec = 3868;
                        }
                        break;
                case ZEND_JMP:
                        if (OP_JMP_ADDR(op, op->op1) > op) {
-                               spec = 3027;
+                               spec = 3025;
                        }
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 3916;
+                               spec = 3914;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3911 | SPEC_RULE_OP1;
+                               spec = 3909 | 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 = 3918 | SPEC_RULE_RETVAL;
+                               spec = 3916 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -65352,17 +65311,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 = 3881 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3879 | 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 = 3917;
+                               spec = 3915;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3906 | SPEC_RULE_OP1;
+                               spec = 3904 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 375231fd52f8805f23be2fca8d3490ca00fc8f00..5decb97c40cc4c203c8c336891f5f2e186b1e2f8 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1317,743 +1317,741 @@
        _(2595, ZEND_JMP_SET_SPEC_VAR) \
        _(2597, ZEND_JMP_SET_SPEC_CV) \
        _(2598, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
-       _(2599, ZEND_ADD_TRAIT_SPEC) \
-       _(2600, ZEND_BIND_TRAITS_SPEC) \
-       _(2601, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
-       _(2602, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
-       _(2603, ZEND_CALL_TRAMPOLINE_SPEC) \
-       _(2604, ZEND_DISCARD_EXCEPTION_SPEC) \
-       _(2605, ZEND_YIELD_SPEC_CONST_CONST) \
-       _(2606, ZEND_YIELD_SPEC_CONST_TMP) \
-       _(2607, ZEND_YIELD_SPEC_CONST_VAR) \
-       _(2608, ZEND_YIELD_SPEC_CONST_UNUSED) \
-       _(2609, ZEND_YIELD_SPEC_CONST_CV) \
-       _(2610, ZEND_YIELD_SPEC_TMP_CONST) \
-       _(2611, ZEND_YIELD_SPEC_TMP_TMP) \
-       _(2612, ZEND_YIELD_SPEC_TMP_VAR) \
-       _(2613, ZEND_YIELD_SPEC_TMP_UNUSED) \
-       _(2614, ZEND_YIELD_SPEC_TMP_CV) \
-       _(2615, ZEND_YIELD_SPEC_VAR_CONST) \
-       _(2616, ZEND_YIELD_SPEC_VAR_TMP) \
-       _(2617, ZEND_YIELD_SPEC_VAR_VAR) \
-       _(2618, ZEND_YIELD_SPEC_VAR_UNUSED) \
-       _(2619, ZEND_YIELD_SPEC_VAR_CV) \
-       _(2620, ZEND_YIELD_SPEC_UNUSED_CONST) \
-       _(2621, ZEND_YIELD_SPEC_UNUSED_TMP) \
-       _(2622, ZEND_YIELD_SPEC_UNUSED_VAR) \
-       _(2623, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
-       _(2624, ZEND_YIELD_SPEC_UNUSED_CV) \
-       _(2625, ZEND_YIELD_SPEC_CV_CONST) \
-       _(2626, ZEND_YIELD_SPEC_CV_TMP) \
-       _(2627, ZEND_YIELD_SPEC_CV_VAR) \
-       _(2628, ZEND_YIELD_SPEC_CV_UNUSED) \
-       _(2629, ZEND_YIELD_SPEC_CV_CV) \
-       _(2630, ZEND_GENERATOR_RETURN_SPEC_CONST) \
-       _(2631, ZEND_GENERATOR_RETURN_SPEC_TMP) \
-       _(2632, ZEND_GENERATOR_RETURN_SPEC_VAR) \
-       _(2634, ZEND_GENERATOR_RETURN_SPEC_CV) \
-       _(2635, ZEND_FAST_CALL_SPEC) \
-       _(2636, ZEND_FAST_RET_SPEC) \
-       _(2637, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
-       _(2638, ZEND_SEND_UNPACK_SPEC) \
-       _(2639, ZEND_POW_SPEC_CONST_CONST) \
-       _(2640, ZEND_POW_SPEC_CONST_TMPVAR) \
-       _(2641, ZEND_POW_SPEC_CONST_TMPVAR) \
-       _(2643, ZEND_POW_SPEC_CONST_CV) \
-       _(2644, ZEND_POW_SPEC_TMPVAR_CONST) \
-       _(2645, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2646, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2648, ZEND_POW_SPEC_TMPVAR_CV) \
-       _(2649, ZEND_POW_SPEC_TMPVAR_CONST) \
-       _(2650, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2651, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2653, ZEND_POW_SPEC_TMPVAR_CV) \
-       _(2659, ZEND_POW_SPEC_CV_CONST) \
-       _(2660, ZEND_POW_SPEC_CV_TMPVAR) \
-       _(2661, ZEND_POW_SPEC_CV_TMPVAR) \
-       _(2663, ZEND_POW_SPEC_CV_CV) \
-       _(2694, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \
-       _(2695, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \
-       _(2696, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \
-       _(2697, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
-       _(2698, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
-       _(2699, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
-       _(2700, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
-       _(2701, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
-       _(2702, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
-       _(2704, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \
-       _(2706, ZEND_ASSIGN_POW_SPEC_VAR_CV) \
-       _(2707, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \
-       _(2708, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \
-       _(2711, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \
-       _(2714, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(2717, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(2723, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \
-       _(2724, ZEND_ASSIGN_POW_SPEC_CV_CONST) \
-       _(2725, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \
-       _(2726, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \
-       _(2727, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
-       _(2728, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
-       _(2729, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
-       _(2730, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
-       _(2731, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
-       _(2732, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
-       _(2734, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \
-       _(2736, ZEND_ASSIGN_POW_SPEC_CV_CV) \
-       _(2737, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \
-       _(2738, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \
-       _(2739, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
-       _(2740, ZEND_COALESCE_SPEC_CONST) \
-       _(2741, ZEND_COALESCE_SPEC_TMPVAR) \
-       _(2742, ZEND_COALESCE_SPEC_TMPVAR) \
-       _(2744, ZEND_COALESCE_SPEC_CV) \
-       _(2745, ZEND_SPACESHIP_SPEC_CONST_CONST) \
-       _(2746, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-       _(2747, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-       _(2749, ZEND_SPACESHIP_SPEC_CONST_CV) \
-       _(2750, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-       _(2751, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2752, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2754, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-       _(2755, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-       _(2756, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2757, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2759, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-       _(2765, ZEND_SPACESHIP_SPEC_CV_CONST) \
-       _(2766, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-       _(2767, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-       _(2769, ZEND_SPACESHIP_SPEC_CV_CV) \
-       _(2770, ZEND_DECLARE_ANON_CLASS_SPEC) \
-       _(2771, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \
-       _(2772, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \
-       _(2774, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \
-       _(2775, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \
-       _(2777, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
-       _(2779, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
-       _(2780, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
-       _(2782, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
-       _(2784, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
-       _(2785, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
-       _(2792, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \
-       _(2794, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \
-       _(2795, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \
-       _(2797, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \
-       _(2799, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \
-       _(2800, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \
-       _(2802, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
-       _(2804, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
-       _(2805, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
-       _(2807, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
-       _(2809, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
-       _(2810, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
-       _(2817, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \
-       _(2819, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \
-       _(2820, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \
-       _(2822, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \
-       _(2824, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \
-       _(2825, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \
-       _(2827, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
-       _(2829, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
-       _(2830, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
-       _(2832, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
-       _(2834, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
-       _(2835, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
-       _(2842, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \
-       _(2844, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \
-       _(2845, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \
-       _(2847, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \
-       _(2849, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \
-       _(2850, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \
-       _(2852, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
-       _(2854, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
-       _(2855, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
-       _(2857, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
-       _(2859, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
-       _(2860, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
-       _(2867, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \
-       _(2869, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \
-       _(2870, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \
-       _(2872, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \
-       _(2874, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \
-       _(2875, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \
-       _(2877, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
-       _(2879, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
-       _(2880, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(2882, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
-       _(2884, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
-       _(2885, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(2892, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \
-       _(2894, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \
-       _(2895, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \
-       _(2897, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \
-       _(2899, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \
-       _(2900, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \
-       _(2902, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
-       _(2904, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
-       _(2905, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(2907, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
-       _(2909, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
-       _(2910, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(2917, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \
-       _(2919, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \
-       _(2920, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \
-       _(2922, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \
-       _(2924, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \
-       _(2925, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \
-       _(2927, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2929, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2930, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2932, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2934, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2935, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2942, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \
-       _(2944, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \
-       _(2945, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \
-       _(2947, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \
-       _(2949, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \
-       _(2950, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \
-       _(2952, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2954, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2955, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2957, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2959, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2960, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2967, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \
-       _(2969, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \
-       _(2970, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \
-       _(2972, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
-       _(2974, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
-       _(2975, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
-       _(2977, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
-       _(2978, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
-       _(2979, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
-       _(2980, ZEND_SEND_FUNC_ARG_SPEC_VAR) \
-       _(2981, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
-       _(2982, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
-       _(2983, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+       _(2599, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
+       _(2600, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
+       _(2601, ZEND_CALL_TRAMPOLINE_SPEC) \
+       _(2602, ZEND_DISCARD_EXCEPTION_SPEC) \
+       _(2603, ZEND_YIELD_SPEC_CONST_CONST) \
+       _(2604, ZEND_YIELD_SPEC_CONST_TMP) \
+       _(2605, ZEND_YIELD_SPEC_CONST_VAR) \
+       _(2606, ZEND_YIELD_SPEC_CONST_UNUSED) \
+       _(2607, ZEND_YIELD_SPEC_CONST_CV) \
+       _(2608, ZEND_YIELD_SPEC_TMP_CONST) \
+       _(2609, ZEND_YIELD_SPEC_TMP_TMP) \
+       _(2610, ZEND_YIELD_SPEC_TMP_VAR) \
+       _(2611, ZEND_YIELD_SPEC_TMP_UNUSED) \
+       _(2612, ZEND_YIELD_SPEC_TMP_CV) \
+       _(2613, ZEND_YIELD_SPEC_VAR_CONST) \
+       _(2614, ZEND_YIELD_SPEC_VAR_TMP) \
+       _(2615, ZEND_YIELD_SPEC_VAR_VAR) \
+       _(2616, ZEND_YIELD_SPEC_VAR_UNUSED) \
+       _(2617, ZEND_YIELD_SPEC_VAR_CV) \
+       _(2618, ZEND_YIELD_SPEC_UNUSED_CONST) \
+       _(2619, ZEND_YIELD_SPEC_UNUSED_TMP) \
+       _(2620, ZEND_YIELD_SPEC_UNUSED_VAR) \
+       _(2621, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
+       _(2622, ZEND_YIELD_SPEC_UNUSED_CV) \
+       _(2623, ZEND_YIELD_SPEC_CV_CONST) \
+       _(2624, ZEND_YIELD_SPEC_CV_TMP) \
+       _(2625, ZEND_YIELD_SPEC_CV_VAR) \
+       _(2626, ZEND_YIELD_SPEC_CV_UNUSED) \
+       _(2627, ZEND_YIELD_SPEC_CV_CV) \
+       _(2628, ZEND_GENERATOR_RETURN_SPEC_CONST) \
+       _(2629, ZEND_GENERATOR_RETURN_SPEC_TMP) \
+       _(2630, ZEND_GENERATOR_RETURN_SPEC_VAR) \
+       _(2632, ZEND_GENERATOR_RETURN_SPEC_CV) \
+       _(2633, ZEND_FAST_CALL_SPEC) \
+       _(2634, ZEND_FAST_RET_SPEC) \
+       _(2635, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
+       _(2636, ZEND_SEND_UNPACK_SPEC) \
+       _(2637, ZEND_POW_SPEC_CONST_CONST) \
+       _(2638, ZEND_POW_SPEC_CONST_TMPVAR) \
+       _(2639, ZEND_POW_SPEC_CONST_TMPVAR) \
+       _(2641, ZEND_POW_SPEC_CONST_CV) \
+       _(2642, ZEND_POW_SPEC_TMPVAR_CONST) \
+       _(2643, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2644, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2646, ZEND_POW_SPEC_TMPVAR_CV) \
+       _(2647, ZEND_POW_SPEC_TMPVAR_CONST) \
+       _(2648, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2649, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2651, ZEND_POW_SPEC_TMPVAR_CV) \
+       _(2657, ZEND_POW_SPEC_CV_CONST) \
+       _(2658, ZEND_POW_SPEC_CV_TMPVAR) \
+       _(2659, ZEND_POW_SPEC_CV_TMPVAR) \
+       _(2661, ZEND_POW_SPEC_CV_CV) \
+       _(2692, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \
+       _(2693, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \
+       _(2694, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \
+       _(2695, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
+       _(2696, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
+       _(2697, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
+       _(2698, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
+       _(2699, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
+       _(2700, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
+       _(2702, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \
+       _(2704, ZEND_ASSIGN_POW_SPEC_VAR_CV) \
+       _(2705, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \
+       _(2706, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \
+       _(2709, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \
+       _(2712, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(2715, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(2721, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \
+       _(2722, ZEND_ASSIGN_POW_SPEC_CV_CONST) \
+       _(2723, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \
+       _(2724, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \
+       _(2725, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
+       _(2726, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
+       _(2727, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
+       _(2728, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
+       _(2729, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
+       _(2730, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
+       _(2732, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \
+       _(2734, ZEND_ASSIGN_POW_SPEC_CV_CV) \
+       _(2735, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \
+       _(2736, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \
+       _(2737, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
+       _(2738, ZEND_COALESCE_SPEC_CONST) \
+       _(2739, ZEND_COALESCE_SPEC_TMPVAR) \
+       _(2740, ZEND_COALESCE_SPEC_TMPVAR) \
+       _(2742, ZEND_COALESCE_SPEC_CV) \
+       _(2743, ZEND_SPACESHIP_SPEC_CONST_CONST) \
+       _(2744, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+       _(2745, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+       _(2747, ZEND_SPACESHIP_SPEC_CONST_CV) \
+       _(2748, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+       _(2749, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(2750, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(2752, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+       _(2753, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+       _(2754, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(2755, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(2757, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+       _(2763, ZEND_SPACESHIP_SPEC_CV_CONST) \
+       _(2764, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+       _(2765, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+       _(2767, ZEND_SPACESHIP_SPEC_CV_CV) \
+       _(2768, ZEND_DECLARE_ANON_CLASS_SPEC) \
+       _(2769, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \
+       _(2770, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \
+       _(2772, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \
+       _(2773, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \
+       _(2775, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
+       _(2777, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
+       _(2778, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
+       _(2780, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
+       _(2782, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
+       _(2783, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
+       _(2790, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \
+       _(2792, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \
+       _(2793, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \
+       _(2795, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \
+       _(2797, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \
+       _(2798, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \
+       _(2800, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
+       _(2802, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
+       _(2803, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
+       _(2805, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
+       _(2807, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
+       _(2808, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
+       _(2815, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \
+       _(2817, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \
+       _(2818, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \
+       _(2820, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \
+       _(2822, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \
+       _(2823, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \
+       _(2825, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
+       _(2827, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
+       _(2828, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
+       _(2830, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
+       _(2832, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
+       _(2833, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
+       _(2840, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \
+       _(2842, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \
+       _(2843, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \
+       _(2845, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \
+       _(2847, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \
+       _(2848, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \
+       _(2850, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
+       _(2852, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
+       _(2853, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
+       _(2855, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
+       _(2857, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
+       _(2858, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
+       _(2865, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \
+       _(2867, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \
+       _(2868, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \
+       _(2870, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \
+       _(2872, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \
+       _(2873, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \
+       _(2875, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
+       _(2877, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
+       _(2878, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(2880, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
+       _(2882, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
+       _(2883, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(2890, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \
+       _(2892, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \
+       _(2893, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \
+       _(2895, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \
+       _(2897, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \
+       _(2898, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \
+       _(2900, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
+       _(2902, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
+       _(2903, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(2905, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
+       _(2907, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
+       _(2908, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(2915, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \
+       _(2917, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \
+       _(2918, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \
+       _(2920, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \
+       _(2922, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \
+       _(2923, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(2925, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(2927, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(2928, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(2930, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(2932, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(2933, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(2940, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \
+       _(2942, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \
+       _(2943, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(2945, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \
+       _(2947, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \
+       _(2948, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(2950, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(2952, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(2953, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(2955, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(2957, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(2958, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(2965, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \
+       _(2967, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \
+       _(2968, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(2970, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
+       _(2972, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
+       _(2973, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
+       _(2975, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
+       _(2976, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
+       _(2977, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
+       _(2978, ZEND_SEND_FUNC_ARG_SPEC_VAR) \
+       _(2979, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
+       _(2980, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
+       _(2981, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+       _(2982, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
        _(2984, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-       _(2986, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-       _(2987, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
-       _(2988, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+       _(2985, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
+       _(2986, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+       _(2987, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
        _(2989, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-       _(2991, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-       _(2992, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
-       _(2993, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
-       _(2994, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
-       _(2996, ZEND_IN_ARRAY_SPEC_CV_CONST) \
-       _(2997, ZEND_COUNT_SPEC_CONST_UNUSED) \
-       _(2998, ZEND_COUNT_SPEC_TMP_UNUSED) \
-       _(2999, ZEND_COUNT_SPEC_VAR_UNUSED) \
-       _(3001, ZEND_COUNT_SPEC_CV_UNUSED) \
-       _(3002, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
-       _(3003, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \
-       _(3004, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \
-       _(3005, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
-       _(3006, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
-       _(3007, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
-       _(3008, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
-       _(3009, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
-       _(3010, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
-       _(3012, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
-       _(3013, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
-       _(3014, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
-       _(3017, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
-       _(3019, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
-       _(3020, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
-       _(3021, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
-       _(3022, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
-       _(3023, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-       _(3024, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-       _(3026, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
-       _(3027, ZEND_JMP_FORWARD_SPEC) \
-       _(3033, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3034, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(2990, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
+       _(2991, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
+       _(2992, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
+       _(2994, ZEND_IN_ARRAY_SPEC_CV_CONST) \
+       _(2995, ZEND_COUNT_SPEC_CONST_UNUSED) \
+       _(2996, ZEND_COUNT_SPEC_TMP_UNUSED) \
+       _(2997, ZEND_COUNT_SPEC_VAR_UNUSED) \
+       _(2999, ZEND_COUNT_SPEC_CV_UNUSED) \
+       _(3000, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
+       _(3001, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \
+       _(3002, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \
+       _(3003, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
+       _(3004, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
+       _(3005, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
+       _(3006, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
+       _(3007, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
+       _(3008, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
+       _(3010, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
+       _(3011, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
+       _(3012, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
+       _(3015, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
+       _(3017, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
+       _(3018, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
+       _(3019, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
+       _(3020, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
+       _(3021, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+       _(3022, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+       _(3024, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
+       _(3025, ZEND_JMP_FORWARD_SPEC) \
+       _(3031, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3032, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3033, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3035, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3036, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3037, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3038, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3039, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3038, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3040, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3042, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3048, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3049, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3046, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3047, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3048, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3050, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3052, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3058, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3059, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3056, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3057, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3058, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3060, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3061, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3062, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3063, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3064, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3063, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3065, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3067, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3073, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3074, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3071, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3072, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3073, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3075, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3077, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3083, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3084, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3081, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3082, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3083, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3085, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3086, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3087, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3088, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3089, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3088, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3090, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3092, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3098, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3099, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3096, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3097, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3098, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3100, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3102, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3104, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3102, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3103, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
        _(3105, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3107, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3108, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3109, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3106, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3107, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3108, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3110, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3111, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3112, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3113, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3114, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3113, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3115, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3117, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3123, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3124, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3121, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3122, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3123, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3125, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3127, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3129, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3127, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3128, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
        _(3130, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3132, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3133, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3134, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3131, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3132, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3133, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3135, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3136, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3137, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3138, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3139, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3138, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3140, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3142, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3148, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3149, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3146, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3147, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3148, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3150, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3152, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3154, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3152, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3153, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
        _(3155, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3157, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3158, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3159, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3156, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3157, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3158, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3160, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3161, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3162, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3163, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3164, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3163, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3165, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3167, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3173, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3174, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3171, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3172, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3173, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3175, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3177, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3183, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3184, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3181, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3182, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3183, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3185, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3186, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3187, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3188, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3189, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3188, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3190, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3192, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3198, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3199, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3196, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3197, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3198, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3200, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3202, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3208, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3209, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3206, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3207, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3208, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3210, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3211, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3212, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3213, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3214, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3213, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3215, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3217, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3223, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3224, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3221, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3222, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3223, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3225, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3227, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3233, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3234, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3231, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3232, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3233, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3235, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3236, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3237, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3238, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3239, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3238, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3240, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3242, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3248, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3249, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3246, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3247, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3248, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3250, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3252, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3268, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3269, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3270, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3271, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3272, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3273, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3274, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3275, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3276, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3280, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3281, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3282, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3283, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3284, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3285, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3286, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3287, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3288, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3289, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3290, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3296, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3297, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3313, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3314, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3315, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3319, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3320, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3321, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3325, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3326, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3327, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3343, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3344, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3345, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3346, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3347, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3348, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3349, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3350, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3351, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3355, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3356, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3357, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3358, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3359, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3360, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3361, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3362, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3363, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3364, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3365, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3371, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3372, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3388, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3389, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3390, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3394, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3395, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3396, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3400, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3401, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3402, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3418, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3419, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3420, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3421, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3422, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3423, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3424, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3425, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3426, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3430, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3431, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3432, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3433, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3434, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3435, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3436, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3437, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3438, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3439, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3440, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3446, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3447, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3463, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3464, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3465, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3469, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3470, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3471, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3475, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3476, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3477, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3493, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3494, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3495, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3496, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3497, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3498, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3499, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3500, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3501, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3505, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3506, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3507, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3508, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3509, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3510, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3511, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3512, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3513, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3514, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3515, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3521, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3522, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3538, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3539, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3540, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3544, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3545, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3546, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3550, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3551, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3552, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3556, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3557, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3558, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3559, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3560, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3561, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3565, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3566, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3567, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3568, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3569, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3570, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3571, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3572, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3573, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3574, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3575, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3576, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3580, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3581, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3582, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3583, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3584, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3585, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3586, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3587, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3588, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3589, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3590, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3596, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3597, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3613, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3614, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3615, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3619, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3620, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3621, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3625, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3626, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3627, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3631, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3632, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3633, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3634, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3635, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3636, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3640, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3641, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3642, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3643, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3644, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3645, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3646, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3647, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3648, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3649, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3650, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3651, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3658, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3659, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3660, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3665, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3671, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3672, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3688, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3689, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3690, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3694, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3695, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3696, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3700, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3701, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3702, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3706, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3707, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3708, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3709, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3710, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3711, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3715, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3716, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3717, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3718, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3719, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3720, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3721, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3722, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3723, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3724, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3725, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3726, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3733, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3734, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3735, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3740, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3746, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3747, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3763, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3764, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3765, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3769, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3770, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3771, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3775, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3776, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3777, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3781, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3782, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3783, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3784, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3785, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3786, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3790, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3791, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3792, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3793, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3794, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3795, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3796, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3797, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3798, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3799, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3800, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3801, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3808, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3809, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3810, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3815, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3821, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3822, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3838, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3839, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3840, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3844, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3845, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3846, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3850, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3851, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3852, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3853, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3854, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3855, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3856, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3857, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3858, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3859, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3860, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3861, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3862, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3863, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3864, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3865, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3866, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
-       _(3867, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3868, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3869, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
-       _(3870, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3871, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(3872, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3266, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3267, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3268, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3269, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3270, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3271, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3272, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3273, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3274, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3278, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3279, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3280, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3281, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3282, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3283, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3284, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3285, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3286, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3287, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3288, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3289, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3294, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3313, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3314, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3315, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3319, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3323, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3324, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3325, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3341, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3342, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3343, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3344, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3345, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3346, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3347, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3348, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3349, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3353, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3354, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3355, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3356, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3357, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3358, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3359, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3360, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3361, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3362, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3363, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3364, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3369, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3388, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3389, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3390, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3394, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3398, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3399, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3400, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3416, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3417, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3418, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3419, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3420, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3421, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3422, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3423, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3424, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3428, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3429, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3430, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3431, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3432, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3433, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3434, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3435, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3436, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3437, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3438, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3439, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3444, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3463, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3464, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3465, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3469, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3473, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3474, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3475, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3491, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3492, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3493, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3494, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3495, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3496, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3497, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3498, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3499, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3503, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3504, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3505, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3506, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3507, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3508, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3509, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3510, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3511, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3512, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3513, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3514, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3519, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3538, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3539, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3540, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3544, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3548, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3549, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3550, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3554, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3555, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3556, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3557, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3558, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3559, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3563, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3564, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3565, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3566, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3567, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3568, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3569, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3570, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3571, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3572, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3573, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3574, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3578, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3579, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3580, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3581, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3582, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3583, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3584, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3585, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3586, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3587, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3588, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3589, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3594, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3613, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3614, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3615, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3619, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3623, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3624, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3625, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3629, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3630, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3631, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3632, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3633, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3634, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3638, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3639, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3640, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3641, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3642, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3643, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3644, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3645, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3646, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3647, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3648, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3649, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3658, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3659, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3660, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3669, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3688, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3689, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3690, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3694, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3698, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3699, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3700, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3704, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3705, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3706, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3707, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3708, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3709, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3713, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3714, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3715, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3716, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3717, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3718, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3719, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3720, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3721, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3722, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3723, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3724, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3733, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3734, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3735, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3744, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3763, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3764, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3765, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3769, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3773, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3774, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3775, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3779, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3780, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3781, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3782, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3783, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3784, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3788, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3789, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3790, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3791, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3792, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3793, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3794, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3795, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3796, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3797, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3798, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3799, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3808, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3809, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3810, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3819, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3838, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3839, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3840, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3844, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3848, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3849, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3850, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3851, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3852, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3853, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3854, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3855, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3856, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3857, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3858, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3859, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3860, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3861, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3862, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3863, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(3864, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+       _(3865, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(3866, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(3867, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+       _(3868, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(3869, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+       _(3870, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3871, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
        _(3873, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3875, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3876, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(3877, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(3874, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+       _(3875, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(3876, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
        _(3878, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3880, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3882, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(3880, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(3881, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
        _(3883, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3885, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3886, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3887, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3884, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(3885, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3886, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
        _(3888, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3889, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
        _(3890, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3891, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3892, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3891, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
        _(3893, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3895, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3901, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(3902, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(3899, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+       _(3900, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(3901, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
        _(3903, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3905, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3908, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(3910, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(3913, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(3915, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(3916, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(3917, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(3918, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(3919, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(3919+1, ZEND_NULL)
+       _(3906, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(3908, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(3911, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(3913, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(3914, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(3915, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(3916, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(3917, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(3917+1, ZEND_NULL)

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index e5f14af348bd09272e18c3f0c1501a14c05c1f57..9d8024285308e9b2ef6f2818c81289177060a658 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -177,8 +177,8 @@ static const char *zend_vm_opcodes_names[199] = {
        "ZEND_ASSERT_CHECK",
        "ZEND_JMP_SET",
        "ZEND_DECLARE_LAMBDA_FUNCTION",
-       "ZEND_ADD_TRAIT",
-       "ZEND_BIND_TRAITS",
+       NULL,
+       NULL,
        "ZEND_SEPARATE",
        "ZEND_FETCH_CLASS_NAME",
        "ZEND_CALL_TRAMPOLINE",
@@ -379,7 +379,7 @@ static uint32_t zend_vm_opcodes_flags[199] = {
        0x00002000,
        0x00002003,
        0x00000103,
-       0x00040000,
+       0x00000000,
        0x00000000,
        0x00000101,
        0x00000071,

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index b5c0a483d83f897c512ce503dbba347598d14a4c..b6df6ef87330de18bc194bbf63b35d229c3a68ae 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -228,8 +228,6 @@ END_EXTERN_C()
 #define ZEND_ASSERT_CHECK                    151
 #define ZEND_JMP_SET                         152
 #define ZEND_DECLARE_LAMBDA_FUNCTION         153
-#define ZEND_ADD_TRAIT                       154
-#define ZEND_BIND_TRAITS                     155
 #define ZEND_SEPARATE                        156
 #define ZEND_FETCH_CLASS_NAME                157
 #define ZEND_CALL_TRAMPOLINE                 158

diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index e10b9feab0127c6c960c9a3a3f16114a20ae54ac..228e1d06e4048060ded344ac682a23cf919570d0 100644 (file)
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -199,7 +199,6 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                        break;
                                case ZEND_FETCH_CLASS:
                                case ZEND_ADD_INTERFACE:
-                               case ZEND_ADD_TRAIT:
                                case ZEND_INSTANCEOF:
                                        if (opline->op2_type == IS_CONST) {
                                                LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 2);

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 632a36782f8f62d3a7416b8783644cb22bd22c92..343c678f2dfb304edff65c39b872fbf879d0ab2d 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -237,8 +237,6 @@ static zend_bool can_replace_op1(
                /* Do not accept CONST */
                case ZEND_VERIFY_ABSTRACT_CLASS:
                case ZEND_ADD_INTERFACE:
-               case ZEND_ADD_TRAIT:
-               case ZEND_BIND_TRAITS:
                case ZEND_ROPE_ADD:
                case ZEND_ROPE_END:
                case ZEND_BIND_STATIC:

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 3904a6d35ad324b164f872baf6c45a93e461aa84..ffda72355810025498db388c84684663122967db 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -391,7 +391,6 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                                return 0;
                        }
                case ZEND_ADD_INTERFACE:
-               case ZEND_ADD_TRAIT:
                        REQUIRES_STRING(val);
                        drop_leading_backslash(val);
                        opline->op2.constant = zend_optimizer_add_literal(op_array, val);

diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
index 2295b257af0694ef5838d0cdb16931112384e554..f589c7e17285dce306f1b88f1b537308141f5891 100644 (file)
--- a/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@ -371,40 +371,47 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
        zend_update_inherited_handler(__debugInfo);
 
 /* 5.4 traits */
-       if (ce->trait_aliases) {
-               zend_trait_alias **trait_aliases;
-               int i = 0;
+       if (ce->num_traits) {
+               zend_class_name *trait_names = emalloc(sizeof(zend_class_name) * ce->num_traits);
 
-               while (ce->trait_aliases[i]) {
-                       i++;
-               }
-               trait_aliases = emalloc(sizeof(zend_trait_alias*) * (i + 1));
-               i = 0;
-               while (ce->trait_aliases[i]) {
-                       trait_aliases[i] = emalloc(sizeof(zend_trait_alias));
-                       memcpy(trait_aliases[i], ce->trait_aliases[i], sizeof(zend_trait_alias));
-                       i++;
-               }
-               trait_aliases[i] = NULL;
-               ce->trait_aliases = trait_aliases;
-       }
+               memcpy(trait_names, ce->trait_names, sizeof(zend_class_name) * ce->num_traits);
+               ce->trait_names = trait_names;
 
-       if (ce->trait_precedences) {
-               zend_trait_precedence **trait_precedences;
-               int i = 0;
+               if (ce->trait_aliases) {
+                       zend_trait_alias **trait_aliases;
+                       int i = 0;
 
-               while (ce->trait_precedences[i]) {
-                       i++;
+                       while (ce->trait_aliases[i]) {
+                               i++;
+                       }
+                       trait_aliases = emalloc(sizeof(zend_trait_alias*) * (i + 1));
+                       i = 0;
+                       while (ce->trait_aliases[i]) {
+                               trait_aliases[i] = emalloc(sizeof(zend_trait_alias));
+                               memcpy(trait_aliases[i], ce->trait_aliases[i], sizeof(zend_trait_alias));
+                               i++;
+                       }
+                       trait_aliases[i] = NULL;
+                       ce->trait_aliases = trait_aliases;
                }
-               trait_precedences = emalloc(sizeof(zend_trait_precedence*) * (i + 1));
-               i = 0;
-               while (ce->trait_precedences[i]) {
-                       trait_precedences[i] = emalloc(sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
-                       memcpy(trait_precedences[i], ce->trait_precedences[i], sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
-                       i++;
+
+               if (ce->trait_precedences) {
+                       zend_trait_precedence **trait_precedences;
+                       int i = 0;
+
+                       while (ce->trait_precedences[i]) {
+                               i++;
+                       }
+                       trait_precedences = emalloc(sizeof(zend_trait_precedence*) * (i + 1));
+                       i = 0;
+                       while (ce->trait_precedences[i]) {
+                               trait_precedences[i] = emalloc(sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
+                               memcpy(trait_precedences[i], ce->trait_precedences[i], sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
+                               i++;
+                       }
+                       trait_precedences[i] = NULL;
+                       ce->trait_precedences = trait_precedences;
                }
-               trait_precedences[i] = NULL;
-               ce->trait_precedences = trait_precedences;
        }
 }
 

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 8a4953c39fff947e188727ed9a0105e2f1beba15..f025acb652cc3e773f7c9adc4e90ff4e6b687efe 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -644,56 +644,70 @@ static void zend_file_cache_serialize_class(zval                     *zv,
        SERIALIZE_STR(ce->info.user.doc_comment);
        zend_file_cache_serialize_hash(&ce->properties_info, script, info, buf, zend_file_cache_serialize_prop_info);
 
-       if (ce->trait_aliases) {
-               zend_trait_alias **p, *q;
+       if (ce->num_traits) {
+               uint32_t i;
+               zend_class_name *trait_names;
 
-               SERIALIZE_PTR(ce->trait_aliases);
-               p = ce->trait_aliases;
-               UNSERIALIZE_PTR(p);
+               SERIALIZE_PTR(ce->trait_names);
+               trait_names = ce->trait_names;
+               UNSERIALIZE_PTR(trait_names);
 
-               while (*p) {
-                       SERIALIZE_PTR(*p);
-                       q = *p;
-                       UNSERIALIZE_PTR(q);
+               for (i = 0; i < ce->num_traits; i++) {
+                       SERIALIZE_STR(trait_names[i].name);
+                       SERIALIZE_STR(trait_names[i].lc_name);
+               }
 
-                       if (q->trait_method.method_name) {
-                               SERIALIZE_STR(q->trait_method.method_name);
-                       }
-                       if (q->trait_method.class_name) {
-                               SERIALIZE_STR(q->trait_method.class_name);
-                       }
+               if (ce->trait_aliases) {
+                       zend_trait_alias **p, *q;
 
-                       if (q->alias) {
-                               SERIALIZE_STR(q->alias);
+                       SERIALIZE_PTR(ce->trait_aliases);
+                       p = ce->trait_aliases;
+                       UNSERIALIZE_PTR(p);
+
+                       while (*p) {
+                               SERIALIZE_PTR(*p);
+                               q = *p;
+                               UNSERIALIZE_PTR(q);
+
+                               if (q->trait_method.method_name) {
+                                       SERIALIZE_STR(q->trait_method.method_name);
+                               }
+                               if (q->trait_method.class_name) {
+                                       SERIALIZE_STR(q->trait_method.class_name);
+                               }
+
+                               if (q->alias) {
+                                       SERIALIZE_STR(q->alias);
+                               }
+                               p++;
                        }
-                       p++;
                }
-       }
 
-       if (ce->trait_precedences) {
-               zend_trait_precedence **p, *q;
-               int j;
+               if (ce->trait_precedences) {
+                       zend_trait_precedence **p, *q;
+                       int j;
 
-               SERIALIZE_PTR(ce->trait_precedences);
-               p = ce->trait_precedences;
-               UNSERIALIZE_PTR(p);
+                       SERIALIZE_PTR(ce->trait_precedences);
+                       p = ce->trait_precedences;
+                       UNSERIALIZE_PTR(p);
 
-               while (*p) {
-                       SERIALIZE_PTR(*p);
-                       q = *p;
-                       UNSERIALIZE_PTR(q);
+                       while (*p) {
+                               SERIALIZE_PTR(*p);
+                               q = *p;
+                               UNSERIALIZE_PTR(q);
 
-                       if (q->trait_method.method_name) {
-                               SERIALIZE_STR(q->trait_method.method_name);
-                       }
-                       if (q->trait_method.class_name) {
-                               SERIALIZE_STR(q->trait_method.class_name);
-                       }
+                               if (q->trait_method.method_name) {
+                                       SERIALIZE_STR(q->trait_method.method_name);
+                               }
+                               if (q->trait_method.class_name) {
+                                       SERIALIZE_STR(q->trait_method.class_name);
+                               }
 
-                       for (j = 0; j < q->num_excludes; j++) {
-                               SERIALIZE_STR(q->exclude_class_names[j]);
+                               for (j = 0; j < q->num_excludes; j++) {
+                                       SERIALIZE_STR(q->exclude_class_names[j]);
+                               }
+                               p++;
                        }
-                       p++;
                }
        }
 
@@ -1248,6 +1262,17 @@ static void zend_file_cache_unserialize_class(zval                    *zv,
        zend_file_cache_unserialize_hash(&ce->properties_info,
                        script, buf, zend_file_cache_unserialize_prop_info, NULL);
 
+       if (ce->num_traits) {
+               uint32_t i;
+
+               UNSERIALIZE_PTR(ce->trait_names);
+
+               for (i = 0; i < ce->num_traits; i++) {
+                       UNSERIALIZE_STR(ce->trait_names[i].name);
+                       UNSERIALIZE_STR(ce->trait_names[i].lc_name);
+               }
+       }
+
        if (ce->trait_aliases) {
                zend_trait_alias **p, *q;
 

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 9620420ab33bdc3725736a764d5853fd073ce052..9b27750d6f5297bc79d7cafc012bdd0edcbe8822 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -762,54 +762,59 @@ static void zend_persist_class_entry(zval *zv)
                        }
                }
                zend_hash_persist(&ce->properties_info, zend_persist_property_info);
-               if (ce->num_interfaces && ce->interfaces) {
-                       efree(ce->interfaces);
-               }
-               ce->interfaces = NULL; /* will be filled in on fetch */
 
-               if (ce->num_traits && ce->traits) {
-                       efree(ce->traits);
+               if (ce->num_interfaces) {
+                       ZEND_ASSERT(0);
                }
-               ce->traits = NULL;
 
-               if (ce->trait_aliases) {
-                       int i = 0;
-                       while (ce->trait_aliases[i]) {
-                               if (ce->trait_aliases[i]->trait_method.method_name) {
-                                       zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method.method_name);
-                               }
-                               if (ce->trait_aliases[i]->trait_method.class_name) {
-                                       zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method.class_name);
-                               }
+               if (ce->num_traits) {
+                       uint32_t i = 0;
 
-                               if (ce->trait_aliases[i]->alias) {
-                                       zend_accel_store_interned_string(ce->trait_aliases[i]->alias);
+                       for (i = 0; i < ce->num_traits; i++) {
+                               zend_accel_store_interned_string(ce->trait_names[i].name);
+                               zend_accel_store_interned_string(ce->trait_names[i].lc_name);
+                       }
+                       zend_accel_store(ce->trait_names, sizeof(zend_class_name) * ce->num_traits);
+
+                       i = 0;
+                       if (ce->trait_aliases) {
+                               while (ce->trait_aliases[i]) {
+                                       if (ce->trait_aliases[i]->trait_method.method_name) {
+                                               zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method.method_name);
+                                       }
+                                       if (ce->trait_aliases[i]->trait_method.class_name) {
+                                               zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method.class_name);
+                                       }
+
+                                       if (ce->trait_aliases[i]->alias) {
+                                               zend_accel_store_interned_string(ce->trait_aliases[i]->alias);
+                                       }
+
+                                       zend_accel_store(ce->trait_aliases[i], sizeof(zend_trait_alias));
+                                       i++;
                                }
 
-                               zend_accel_store(ce->trait_aliases[i], sizeof(zend_trait_alias));
-                               i++;
+                               zend_accel_store(ce->trait_aliases, sizeof(zend_trait_alias*) * (i + 1));
                        }
 
-                       zend_accel_store(ce->trait_aliases, sizeof(zend_trait_alias*) * (i + 1));
-               }
+                       if (ce->trait_precedences) {
+                               int j;
 
-               if (ce->trait_precedences) {
-                       int i = 0;
-                       int j;
+                               i = 0;
+                               while (ce->trait_precedences[i]) {
+                                       zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method.method_name);
+                                       zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method.class_name);
 
-                       while (ce->trait_precedences[i]) {
-                               zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method.method_name);
-                               zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method.class_name);
+                                       for (j = 0; j < ce->trait_precedences[i]->num_excludes; j++) {
+                                               zend_accel_store_interned_string(ce->trait_precedences[i]->exclude_class_names[j]);
+                                       }
 
-                               for (j = 0; j < ce->trait_precedences[i]->num_excludes; j++) {
-                                       zend_accel_store_interned_string(ce->trait_precedences[i]->exclude_class_names[j]);
+                                       zend_accel_store(ce->trait_precedences[i], sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
+                                       i++;
                                }
-
-                               zend_accel_store(ce->trait_precedences[i], sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
-                               i++;
+                               zend_accel_store(
+                                       ce->trait_precedences, sizeof(zend_trait_precedence*) * (i + 1));
                        }
-                       zend_accel_store(
-                               ce->trait_precedences, sizeof(zend_trait_precedence*) * (i + 1));
                }
        }
 }

diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 4e08d754c7020292bfe74659c0265f909fdf15e4..c22b79de4d374485b465e0231fbe600404a5407d 100644 (file)
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -342,40 +342,50 @@ static void zend_persist_class_entry_calc(zval *zv)
 
                zend_hash_persist_calc(&ce->properties_info, zend_persist_property_info_calc);
 
-               if (ce->trait_aliases) {
-                       int i = 0;
-                       while (ce->trait_aliases[i]) {
-                               if (ce->trait_aliases[i]->trait_method.method_name) {
-                                       ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.method_name, 0);
-                               }
-                               if (ce->trait_aliases[i]->trait_method.class_name) {
-                                       ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.class_name, 0);
-                               }
+               if (ce->num_traits) {
+                       uint32_t i;
 
-                               if (ce->trait_aliases[i]->alias) {
-                                       ADD_INTERNED_STRING(ce->trait_aliases[i]->alias, 0);
+                       for (i = 0; i < ce->num_traits; i++) {
+                               ADD_INTERNED_STRING(ce->trait_names[i].name, 0);
+                               ADD_INTERNED_STRING(ce->trait_names[i].lc_name, 0);
+                       }
+                       ADD_SIZE(sizeof(zend_class_name) * ce->num_traits);
+
+                       if (ce->trait_aliases) {
+                               i = 0;
+                               while (ce->trait_aliases[i]) {
+                                       if (ce->trait_aliases[i]->trait_method.method_name) {
+                                               ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.method_name, 0);
+                                       }
+                                       if (ce->trait_aliases[i]->trait_method.class_name) {
+                                               ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.class_name, 0);
+                                       }
+
+                                       if (ce->trait_aliases[i]->alias) {
+                                               ADD_INTERNED_STRING(ce->trait_aliases[i]->alias, 0);
+                                       }
+                                       ADD_SIZE(sizeof(zend_trait_alias));
+                                       i++;
                                }
-                               ADD_SIZE(sizeof(zend_trait_alias));
-                               i++;
+                               ADD_SIZE(sizeof(zend_trait_alias*) * (i + 1));
                        }
-                       ADD_SIZE(sizeof(zend_trait_alias*) * (i + 1));
-               }
 
-               if (ce->trait_precedences) {
-                       int i = 0;
-                       int j;
+                       if (ce->trait_precedences) {
+                               int j;
 
-                       while (ce->trait_precedences[i]) {
-                               ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.method_name, 0);
-                               ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.class_name, 0);
+                               i = 0;
+                               while (ce->trait_precedences[i]) {
+                                       ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.method_name, 0);
+                                       ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.class_name, 0);
 
-                               for (j = 0; j < ce->trait_precedences[i]->num_excludes; j++) {
-                                       ADD_INTERNED_STRING(ce->trait_precedences[i]->exclude_class_names[j], 0);
+                                       for (j = 0; j < ce->trait_precedences[i]->num_excludes; j++) {
+                                               ADD_INTERNED_STRING(ce->trait_precedences[i]->exclude_class_names[j], 0);
+                                       }
+                                       ADD_SIZE(sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
+                                       i++;
                                }
-                               ADD_SIZE(sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
-                               i++;
+                               ADD_SIZE(sizeof(zend_trait_precedence*) * (i + 1));
                        }
-                       ADD_SIZE(sizeof(zend_trait_precedence*) * (i + 1));
                }
        }
 }

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 6f34cf29bf53aeafe70663a8092ccfaf76e70e22..c481e79618b756b548fd136b78810669a1658324 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -4888,8 +4888,13 @@ ZEND_METHOD(reflection_class, getTraits)
 
        for (i=0; i < ce->num_traits; i++) {
                zval trait;
-               zend_reflection_class_factory(ce->traits[i], &trait);
-               zend_hash_update(Z_ARRVAL_P(return_value), ce->traits[i]->name, &trait);
+               zend_class_entry *trait_ce;
+
+               trait_ce = zend_fetch_class_by_name(ce->trait_names[i].name,
+                       ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT);
+               ZEND_ASSERT(trait_ce);
+               zend_reflection_class_factory(trait_ce, &trait);
+               zend_hash_update(Z_ARRVAL_P(return_value), ce->trait_names[i].name, &trait);
        }
 }
 /* }}} */
@@ -4915,7 +4920,7 @@ ZEND_METHOD(reflection_class, getTraitNames)
        array_init(return_value);
 
        for (i=0; i < ce->num_traits; i++) {
-               add_next_index_str(return_value, zend_string_copy(ce->traits[i]->name));
+               add_next_index_str(return_value, zend_string_copy(ce->trait_names[i].name));
        }
 }
 /* }}} */

diff --git a/ext/spl/spl_functions.c b/ext/spl/spl_functions.c
index 75e264f34ba28d552fd93d3478ca699f2fc5c1f8..ceb5330a9fac68715b092e4c851427012459839d 100644 (file)
--- a/ext/spl/spl_functions.c
+++ b/ext/spl/spl_functions.c
@@ -104,9 +104,13 @@ void spl_add_interfaces(zval *list, zend_class_entry * pce, int allow, int ce_fl
 void spl_add_traits(zval *list, zend_class_entry * pce, int allow, int ce_flags)
 {
        uint32_t num_traits;
+       zend_class_entry *trait;
 
        for (num_traits = 0; num_traits < pce->num_traits; num_traits++) {
-               spl_add_class_name(list, pce->traits[num_traits], allow, ce_flags);
+               trait = zend_fetch_class_by_name(pce->trait_names[num_traits].name,
+                       pce->trait_names[num_traits].lc_name, ZEND_FETCH_CLASS_TRAIT);
+               ZEND_ASSERT(trait);
+               spl_add_class_name(list, trait, allow, ce_flags);
        }
 }
 /* }}} */

diff --git a/sapi/phpdbg/phpdbg.c b/sapi/phpdbg/phpdbg.c
index 03aaf544314c1ba29838af75d01f643797fc13ae..e686e21941c53243040a61f7d16ed6af7c3a796d 100644 (file)
--- a/sapi/phpdbg/phpdbg.c
+++ b/sapi/phpdbg/phpdbg.c
@@ -481,7 +481,7 @@ static zend_always_inline zend_bool phpdbg_is_ignored_opcode(zend_uchar opcode)
        return
            opcode == ZEND_NOP || opcode == ZEND_OP_DATA || opcode == ZEND_FE_FREE || opcode == ZEND_FREE || opcode == ZEND_ASSERT_CHECK || opcode == ZEND_VERIFY_RETURN_TYPE
         || opcode == ZEND_DECLARE_CONST || opcode == ZEND_DECLARE_CLASS || opcode == ZEND_DECLARE_INHERITED_CLASS || opcode == ZEND_DECLARE_FUNCTION
-        || opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED || opcode == ZEND_VERIFY_ABSTRACT_CLASS || opcode == ZEND_ADD_TRAIT || opcode == ZEND_BIND_TRAITS
+        || opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED || opcode == ZEND_VERIFY_ABSTRACT_CLASS
         || opcode == ZEND_DECLARE_ANON_CLASS || opcode == ZEND_DECLARE_ANON_INHERITED_CLASS || opcode == ZEND_FAST_RET || opcode == ZEND_TICKS
         || opcode == ZEND_EXT_STMT || opcode == ZEND_EXT_FCALL_BEGIN || opcode == ZEND_EXT_FCALL_END || opcode == ZEND_EXT_NOP || opcode == ZEND_BIND_GLOBAL
        ;