diff --git a/Zend/Optimizer/zend_inference.h b/Zend/Optimizer/zend_inference.h index 666abc586592e..84dd30bab2f02 100644 --- a/Zend/Optimizer/zend_inference.h +++ b/Zend/Optimizer/zend_inference.h @@ -157,6 +157,9 @@ static zend_always_inline uint32_t _const_op_type(const zval *zv) { tmp |= MAY_BE_RC1 | MAY_BE_RCN; } else if (Z_TYPE_P(zv) == IS_STRING) { tmp |= MAY_BE_RCN; + } else if (Z_TYPE_P(zv) == IS_ATOM) { + /* Atoms are not refcounted, but store their type precisely */ + tmp = MAY_BE_ATOM; } return tmp; } diff --git a/Zend/tests/atoms_array_keys.phpt b/Zend/tests/atoms_array_keys.phpt new file mode 100644 index 0000000000000..fcc4a552802d1 --- /dev/null +++ b/Zend/tests/atoms_array_keys.phpt @@ -0,0 +1,78 @@ +--TEST-- +Atoms: Array keys functionality +--FILE-- + 'John', + :age => 30, + :status => :active +]; + +// Test array access +var_dump($array[:name]); +var_dump($array[:age]); +var_dump($array[:status]); + +// Test isset +var_dump(isset($array[:name])); +var_dump(isset($array[:nonexistent])); + +// Test array_key_exists +var_dump(array_key_exists('name', $array)); +var_dump(array_key_exists('nonexistent', $array)); + +// Test dynamic assignment +$array[:email] = 'john@example.com'; +var_dump($array[:email]); + +// Test unset +unset($array[:age]); +var_dump(isset($array[:age])); + +// Test nested arrays +$config = [ + :database => [ + :host => 'localhost', + :port => 3306, + :credentials => [ + :username => 'admin', + :password => 'secret' + ] + ], + :cache => [ + :enabled => true, + :driver => :redis + ] +]; + +var_dump($config[:database][:host]); +var_dump($config[:database][:port]); +var_dump($config[:database][:credentials][:username]); +var_dump($config[:cache][:driver]); + +// Test foreach +$simple = [:a => 1, :b => 2, :c => 3]; +foreach ($simple as $key => $value) { + var_dump(string($key) . " => " . $value); +} + +?> +--EXPECT-- +string(4) "John" +int(30) +string(6) "active" +bool(true) +bool(false) +bool(true) +bool(false) +string(16) "john@example.com" +bool(false) +string(9) "localhost" +int(3306) +string(5) "admin" +string(5) "redis" +string(6) "a => 1" +string(6) "b => 2" +string(6) "c => 3" \ No newline at end of file diff --git a/Zend/tests/atoms_basic.phpt b/Zend/tests/atoms_basic.phpt new file mode 100644 index 0000000000000..3410894b8b2e0 --- /dev/null +++ b/Zend/tests/atoms_basic.phpt @@ -0,0 +1,50 @@ +--TEST-- +Atoms: Basic functionality +--FILE-- + +--EXPECT-- +bool(true) +bool(true) +bool(false) +bool(false) +string(4) "atom" +string(4) "atom" +bool(true) +bool(true) +string(4) "test" +string(5) "hello" +string(5) "world" +bool(true) +bool(true) +bool(false) \ No newline at end of file diff --git a/Zend/tests/atoms_comparison.phpt b/Zend/tests/atoms_comparison.phpt new file mode 100644 index 0000000000000..0f28ba95cc52a --- /dev/null +++ b/Zend/tests/atoms_comparison.phpt @@ -0,0 +1,51 @@ +--TEST-- +Atoms: Comparison operations +--FILE-- + +--EXPECT-- +bool(true) +bool(false) +bool(true) +bool(true) +bool(false) +bool(true) +bool(false) +bool(false) +bool(false) +bool(false) +bool(false) +bool(false) +bool(true) +bool(false) +bool(true) \ No newline at end of file diff --git a/Zend/tests/atoms_edge_cases.phpt b/Zend/tests/atoms_edge_cases.phpt new file mode 100644 index 0000000000000..adb1b6ea1b9af --- /dev/null +++ b/Zend/tests/atoms_edge_cases.phpt @@ -0,0 +1,76 @@ +--TEST-- +Atoms: Edge cases and special scenarios +--FILE-- +state; + } +} + +$obj = new TestClass(); +var_dump($obj->status); +var_dump(string($obj->getState())); + +// Test empty array with atom keys +$empty = []; +$empty[:first] = 'value1'; +var_dump($empty[:first]); + +?> +--EXPECT-- +string(9) "test_case" +string(7) "item_123" +string(8) "_private" +string(53) "this_is_a_very_long_atom_name_for_testing_purposes" +bool(true) +bool(true) +bool(false) +int(1) +bool(false) +int(2) +string(4) "test" +string(5) "other" +atom(:ready) +string(11) "initialized" +string(6) "value1" \ No newline at end of file diff --git a/Zend/tests/atoms_error_handling.phpt b/Zend/tests/atoms_error_handling.phpt new file mode 100644 index 0000000000000..63f015d3c0a9e --- /dev/null +++ b/Zend/tests/atoms_error_handling.phpt @@ -0,0 +1,76 @@ +--TEST-- +Atoms: Error handling +--FILE-- + +--EXPECT-- +string(20) "Empty string rejected" +string(26) "Invalid identifier rejected" +string(13) "Null rejected" +string(18) "Non-string rejected" +string(26) "string() rejects non-atom" +string(24) "string() rejects integer" +string(24) "atom_exists rejects null" +string(27) "atom_exists rejects integer" \ No newline at end of file diff --git a/Zend/tests/atoms_function.phpt b/Zend/tests/atoms_function.phpt new file mode 100644 index 0000000000000..5f28980c7ce86 --- /dev/null +++ b/Zend/tests/atoms_function.phpt @@ -0,0 +1,41 @@ +--TEST-- +Atoms: atom() function +--FILE-- + +--EXPECT-- +bool(true) +bool(true) +string(7) "dynamic" +string(4) "test" +bool(true) +bool(true) +bool(true) +bool(true) +string(8) "variable" +bool(true) \ No newline at end of file diff --git a/Zend/tests/atoms_match.phpt b/Zend/tests/atoms_match.phpt new file mode 100644 index 0000000000000..723dd5430d33a --- /dev/null +++ b/Zend/tests/atoms_match.phpt @@ -0,0 +1,70 @@ +--TEST-- +Atoms: Match expression support +--FILE-- + 'Processing pending request', + :success => 'Request completed successfully', + :error => 'Request failed with error', + :timeout => 'Request timed out', + default => 'Unknown status' + }; +} + +// Test match with atoms +var_dump(processStatus(:pending)); +var_dump(processStatus(:success)); +var_dump(processStatus(:error)); +var_dump(processStatus(:timeout)); +var_dump(processStatus(:unknown)); + +// Test match with multiple cases +function getColor($status) { + return match($status) { + :active, :running, :online => 'green', + :pending, :waiting => 'yellow', + :error, :failed, :offline => 'red', + default => 'gray' + }; +} + +var_dump(getColor(:active)); +var_dump(getColor(:running)); +var_dump(getColor(:pending)); +var_dump(getColor(:error)); +var_dump(getColor(:failed)); +var_dump(getColor(:unknown)); + +// Test complex match +function handleApiResponse($response) { + return match([$response[:status], $response[:type] ?? :default]) { + [:success, :user] => 'User operation successful', + [:success, :admin] => 'Admin operation successful', + [:error, :user] => 'User operation failed', + [:error, :admin] => 'Admin operation failed', + default => 'Unknown response type' + }; +} + +var_dump(handleApiResponse([:status => :success, :type => :user])); +var_dump(handleApiResponse([:status => :error, :type => :admin])); +var_dump(handleApiResponse([:status => :pending])); + +?> +--EXPECT-- +string(25) "Processing pending request" +string(29) "Request completed successfully" +string(24) "Request failed with error" +string(17) "Request timed out" +string(14) "Unknown status" +string(5) "green" +string(5) "green" +string(6) "yellow" +string(3) "red" +string(3) "red" +string(4) "gray" +string(26) "User operation successful" +string(22) "Admin operation failed" +string(21) "Unknown response type" \ No newline at end of file diff --git a/Zend/tests/atoms_serialization.phpt b/Zend/tests/atoms_serialization.phpt new file mode 100644 index 0000000000000..098d870613ccd --- /dev/null +++ b/Zend/tests/atoms_serialization.phpt @@ -0,0 +1,66 @@ +--TEST-- +Atoms: Serialization and unserialization +--FILE-- + :success, + :data => [ + :user => :admin, + :permissions => [:read, :write, :delete] + ] +]; + +$serialized_array = serialize($array); +$unserialized_array = unserialize($serialized_array); + +var_dump($array[:status] === $unserialized_array[:status]); +var_dump($array[:data][:user] === $unserialized_array[:data][:user]); +var_dump($array[:data][:permissions][0] === $unserialized_array[:data][:permissions][0]); + +// Test complex structure +$config = [ + :environment => :production, + :services => [ + :database => [ + :type => :mysql, + :config => [ + :host => 'localhost', + :port => 3306 + ] + ], + :cache => [ + :type => :redis, + :enabled => true + ] + ] +]; + +$ser_config = serialize($config); +$unser_config = unserialize($ser_config); + +var_dump($config[:environment] === $unser_config[:environment]); +var_dump($config[:services][:database][:type] === $unser_config[:services][:database][:type]); +var_dump($config[:services][:cache][:type] === $unser_config[:services][:cache][:type]); + +?> +--EXPECT-- +bool(true) +bool(true) +string(4) "test" +bool(true) +bool(true) +bool(true) +bool(true) +bool(true) +bool(true) \ No newline at end of file diff --git a/Zend/tests/atoms_utility_functions.phpt b/Zend/tests/atoms_utility_functions.phpt new file mode 100644 index 0000000000000..6d9cccc5182de --- /dev/null +++ b/Zend/tests/atoms_utility_functions.phpt @@ -0,0 +1,60 @@ +--TEST-- +Atoms: Utility functions +--FILE-- + $initial_count); +var_dump(in_array('first', $atoms)); +var_dump(in_array('second', $atoms)); +var_dump(in_array('third', $atoms)); +var_dump(in_array('nonexistent', $atoms)); + +// Test that get_defined_atoms returns strings +foreach (['first', 'second', 'third'] as $name) { + if (in_array($name, $atoms)) { + var_dump(is_string($name)); + } +} + +// Test atom_exists with invalid input +try { + atom_exists(''); +} catch (ValueError $e) { + var_dump("ValueError caught for empty string"); +} + +?> +--EXPECT-- +bool(false) +bool(true) +bool(false) +bool(true) +bool(true) +bool(true) +bool(true) +bool(true) +bool(false) +bool(true) +bool(true) +bool(true) +string(32) "ValueError caught for empty string" \ No newline at end of file diff --git a/Zend/tests/atoms_var_export.phpt b/Zend/tests/atoms_var_export.phpt new file mode 100644 index 0000000000000..6d061421a8f8d --- /dev/null +++ b/Zend/tests/atoms_var_export.phpt @@ -0,0 +1,61 @@ +--TEST-- +Atoms: var_export functionality +--FILE-- + 'John', + :status => :active, + :permissions => [:read, :write] +]; + +var_export($array); +echo "\n"; + +// Test var_export with nested structure +$config = [ + :database => [ + :host => 'localhost', + :type => :mysql + ], + :cache => :enabled +]; + +var_export($config); +echo "\n"; + +// Test var_dump with atoms +var_dump(:simple); +var_dump([:key => :value]); + +?> +--EXPECT-- +:test +array ( + 'name' => 'John', + 'status' => :active, + 'permissions' => + array ( + 0 => :read, + 1 => :write, + ), +) +array ( + 'database' => + array ( + 'host' => 'localhost', + 'type' => :mysql, + ), + 'cache' => :enabled, +) +atom(:simple) +array(1) { + ["key"]=> + atom(:value) +} \ No newline at end of file diff --git a/Zend/zend.c b/Zend/zend.c index 2d8a0f455f8b4..685772ea74d31 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -33,6 +33,7 @@ #include "zend_smart_string.h" #include "zend_cpuinfo.h" #include "zend_attributes.h" +#include "zend_atom.h" #include "zend_observer.h" #include "zend_fibers.h" #include "zend_call_stack.h" @@ -1055,6 +1056,7 @@ void zend_startup(zend_utility_functions *utility_functions) /* {{{ */ zend_interned_strings_init(); zend_startup_builtin_functions(); + zend_startup_atoms(); zend_register_standard_constants(); zend_register_auto_global(zend_string_init_interned("GLOBALS", sizeof("GLOBALS") - 1, 1), 1, php_auto_globals_create_globals); @@ -1195,6 +1197,7 @@ void zend_shutdown(void) /* {{{ */ free(GLOBAL_CONSTANTS_TABLE); zend_shutdown_strtod(); zend_attributes_shutdown(); + zend_atoms_shutdown(); #ifdef ZTS GLOBAL_FUNCTION_TABLE = NULL; diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 4c31fba5e506e..690fa9dfb5980 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -134,6 +134,8 @@ ZEND_API const char *zend_get_type_by_const(int type) /* {{{ */ return "iterable"; case IS_ARRAY: return "array"; + case IS_ATOM: + return "atom"; case IS_VOID: return "void"; case IS_MIXED: @@ -197,6 +199,8 @@ ZEND_API zend_string *zend_zval_get_legacy_type(const zval *arg) /* {{{ */ return ZSTR_KNOWN(ZEND_STR_STRING); case IS_ARRAY: return ZSTR_KNOWN(ZEND_STR_ARRAY); + case IS_ATOM: + return ZSTR_KNOWN(ZEND_STR_ATOM); case IS_OBJECT: return ZSTR_KNOWN(ZEND_STR_OBJECT); case IS_RESOURCE: diff --git a/Zend/zend_atom.c b/Zend/zend_atom.c new file mode 100644 index 0000000000000..a2fdbcca8b80e --- /dev/null +++ b/Zend/zend_atom.c @@ -0,0 +1,171 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: [Your Name] | + +----------------------------------------------------------------------+ +*/ + +#include "zend.h" +#include "zend_atom.h" +#include "zend_hash.h" +#include "zend_string.h" +#include "zend_alloc.h" + +ZEND_API HashTable atom_table; +ZEND_API uint32_t next_atom_id = 1; /* Start from 1, 0 is reserved for invalid */ +static bool atoms_initialized = false; + +static void atom_dtor(zval *zv) +{ + zend_atom *atom = (zend_atom *)Z_PTR_P(zv); + zend_string_release_ex(atom->name, 1); + pefree(atom, 1); +} + +ZEND_API void zend_atoms_init(void) +{ + zend_hash_init(&atom_table, 64, NULL, atom_dtor, 0); + next_atom_id = 1; +} + +ZEND_API void zend_atoms_shutdown(void) +{ + if (atoms_initialized) { + zend_hash_destroy(&atom_table); + atoms_initialized = false; + } +} + +ZEND_API bool zend_atom_name_is_valid(const char *name, size_t name_len) +{ + if (name_len == 0) { + return false; + } + + /* First character must be [a-zA-Z_\x80-\xff] */ + unsigned char c = (unsigned char)name[0]; + if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c >= 0x80)) { + return false; + } + + /* Subsequent characters must be [a-zA-Z0-9_\x80-\xff] */ + for (size_t i = 1; i < name_len; i++) { + c = (unsigned char)name[i]; + if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || + (c >= '0' && c <= '9') || c == '_' || c >= 0x80)) { + return false; + } + } + + return true; +} + +ZEND_API uint32_t zend_atom_create(zend_string *name) +{ + zval *existing; + zend_atom *atom; + zval atom_zv; + + if (!atoms_initialized) { + zend_startup_atoms(); + } + + /* Check if atom already exists */ + existing = zend_hash_find(&atom_table, name); + if (existing) { + atom = (zend_atom *)Z_PTR_P(existing); + return atom->id; + } + + /* Validate atom name */ + if (!zend_atom_name_is_valid(ZSTR_VAL(name), ZSTR_LEN(name))) { + return ZEND_ATOM_INVALID_ID; + } + + /* Create new atom */ + atom = pemalloc(sizeof(zend_atom), 1); + atom->name = zend_string_init(ZSTR_VAL(name), ZSTR_LEN(name), 1); + atom->id = next_atom_id++; + + ZVAL_PTR(&atom_zv, atom); + zend_hash_add(&atom_table, atom->name, &atom_zv); + + return atom->id; +} + +ZEND_API uint32_t zend_atom_create_cstr(const char *name, size_t name_len) +{ + zend_string *str = zend_string_init(name, name_len, 0); + uint32_t result = zend_atom_create(str); + zend_string_release(str); + return result; +} + +ZEND_API uint32_t zend_atom_find(zend_string *name) +{ + if (!atoms_initialized) { + return ZEND_ATOM_INVALID_ID; + } + + zval *existing = zend_hash_find(&atom_table, name); + if (existing) { + zend_atom *atom = (zend_atom *)Z_PTR_P(existing); + return atom->id; + } + return ZEND_ATOM_INVALID_ID; +} + +ZEND_API uint32_t zend_atom_find_cstr(const char *name, size_t name_len) +{ + zend_string *str = zend_string_init(name, name_len, 0); + uint32_t result = zend_atom_find(str); + zend_string_release(str); + return result; +} + +ZEND_API zend_string *zend_atom_name(uint32_t atom_id) +{ + zval *entry; + zend_atom *atom; + + if (atom_id == ZEND_ATOM_INVALID_ID) { + return NULL; + } + + /* Linear search through atom table to find by ID */ + /* TODO: Consider maintaining a reverse lookup table for performance */ + ZEND_HASH_FOREACH_VAL(&atom_table, entry) { + atom = (zend_atom *)Z_PTR_P(entry); + if (atom->id == atom_id) { + return atom->name; + } + } ZEND_HASH_FOREACH_END(); + + return NULL; +} + +ZEND_API bool zend_atom_exists(zend_string *name) +{ + return zend_hash_exists(&atom_table, name); +} + +ZEND_API void zend_startup_atoms(void) +{ + if (atoms_initialized) { + return; + } + + zend_hash_init(&atom_table, 0, NULL, atom_dtor, 1); + atoms_initialized = true; +} \ No newline at end of file diff --git a/Zend/zend_atom.h b/Zend/zend_atom.h new file mode 100644 index 0000000000000..cecaa5f2eb3e4 --- /dev/null +++ b/Zend/zend_atom.h @@ -0,0 +1,57 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: [Your Name] | + +----------------------------------------------------------------------+ +*/ + +#ifndef ZEND_ATOM_H +#define ZEND_ATOM_H + +#include "zend_types.h" +#include "zend_hash.h" + +BEGIN_EXTERN_C() + +typedef struct _zend_atom { + zend_string *name; /* atom name */ + uint32_t id; /* unique atom ID */ +} zend_atom; + +/* Atom table globals */ +ZEND_API extern HashTable atom_table; +ZEND_API extern uint32_t next_atom_id; + +/* Core atom management functions */ +ZEND_API void zend_atoms_init(void); +ZEND_API void zend_atoms_shutdown(void); +ZEND_API uint32_t zend_atom_create(zend_string *name); +ZEND_API uint32_t zend_atom_find(zend_string *name); +ZEND_API zend_string *zend_atom_name(uint32_t atom_id); +ZEND_API bool zend_atom_exists(zend_string *name); +ZEND_API void zend_startup_atoms(void); + +/* Atom creation from C string (for internal use) */ +ZEND_API uint32_t zend_atom_create_cstr(const char *name, size_t name_len); +ZEND_API uint32_t zend_atom_find_cstr(const char *name, size_t name_len); + +/* Validation */ +ZEND_API bool zend_atom_name_is_valid(const char *name, size_t name_len); + +/* Utility macros */ +#define ZEND_ATOM_INVALID_ID 0 + +END_EXTERN_C() + +#endif /* ZEND_ATOM_H */ \ No newline at end of file diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 2e405de30ea62..0c30242a92b9f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -38,6 +38,7 @@ #include "zend_call_stack.h" #include "zend_frameless_function.h" #include "zend_property_hooks.h" +#include "zend_atom.h" #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ @@ -272,6 +273,7 @@ static const builtin_type_info builtin_types[] = { {ZEND_STRL("iterable"), IS_ITERABLE}, {ZEND_STRL("object"), IS_OBJECT}, {ZEND_STRL("mixed"), IS_MIXED}, + {ZEND_STRL("atom"), IS_ATOM}, {NULL, 0, IS_UNDEF} }; @@ -4123,7 +4125,7 @@ static zend_result zend_compile_func_is_scalar(znode *result, zend_ast_list *arg zend_compile_expr(&arg_node, args->child[0]); opline = zend_emit_op_tmp(result, ZEND_TYPE_CHECK, &arg_node, NULL); - opline->extended_value = (1 << IS_FALSE | 1 << IS_TRUE | 1 << IS_DOUBLE | 1 << IS_LONG | 1 << IS_STRING); + opline->extended_value = (1 << IS_FALSE | 1 << IS_TRUE | 1 << IS_DOUBLE | 1 << IS_LONG | 1 << IS_STRING | 1 << IS_ATOM); return SUCCESS; } @@ -9988,6 +9990,9 @@ static bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */ case IS_NULL: zend_hash_update(Z_ARRVAL_P(result), ZSTR_EMPTY_ALLOC(), value); break; + case IS_ATOM: + zend_hash_update(Z_ARRVAL_P(result), zend_atom_name(Z_ATOM_ID_P(key)), value); + break; default: zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type"); break; diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 4fed2af3a92fd..741278b493768 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -44,6 +44,7 @@ #include "zend_system_id.h" #include "zend_call_stack.h" #include "zend_attributes.h" +#include "zend_atom.h" #include "Optimizer/zend_func_info.h" /* Virtual current working directory support */ @@ -2672,6 +2673,9 @@ static zend_never_inline uint8_t slow_index_convert(HashTable *ht, const zval *d case IS_TRUE: value->lval = 1; return IS_LONG; + case IS_ATOM: + value->str = zend_atom_name(Z_ATOM_ID_P(dim)); + return IS_STRING; default: zend_illegal_array_offset_access(dim); return IS_NULL; @@ -2746,6 +2750,9 @@ static zend_never_inline uint8_t slow_index_convert_w(HashTable *ht, const zval case IS_TRUE: value->lval = 1; return IS_LONG; + case IS_ATOM: + value->str = zend_atom_name(Z_ATOM_ID_P(dim)); + return IS_STRING; default: zend_illegal_array_offset_access(dim); return IS_NULL; @@ -3202,6 +3209,8 @@ static zend_never_inline zval* ZEND_FASTCALL zend_find_array_dim_slow(HashTable zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_idx; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + return zend_hash_find(ht, zend_atom_name(Z_ATOM_ID_P(offset))); } else if (/*OP2_TYPE == IS_CV &&*/ Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); goto str_idx; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 9483a83b4e955..67da496e3aefb 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -89,6 +89,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_LNUMBER "integer" %token T_DNUMBER "floating-point number" %token T_STRING "identifier" +%token T_ATOM "atom" %token T_NAME_FULLY_QUALIFIED "fully qualified name" %token T_NAME_RELATIVE "namespace-relative name" %token T_NAME_QUALIFIED "namespaced name" @@ -1443,6 +1444,7 @@ dereferenceable_scalar: scalar: T_LNUMBER { $$ = $1; } | T_DNUMBER { $$ = $1; } + | T_ATOM { $$ = $1; } | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; } | T_START_HEREDOC T_END_HEREDOC { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); } diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 4c883b81c5f7d..e4fbf147e0db9 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -46,6 +46,7 @@ #include "zend_strtod.h" #include "zend_exceptions.h" #include "zend_virtual_cwd.h" +#include "zend_atom.h" #define YYCTYPE unsigned char #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } } @@ -2394,6 +2395,14 @@ inline_char_handler: RETURN_TOKEN(T_NS_SEPARATOR); } +":"{LABEL} { + zend_string *atom_name = zend_string_init(yytext + 1, yyleng - 1, 0); + uint32_t atom_id = zend_atom_create(atom_name); + zend_string_release(atom_name); + ZVAL_ATOM(zendlval, atom_id); + RETURN_TOKEN_WITH_VAL(T_ATOM); +} + {LABEL} { RETURN_TOKEN_WITH_STR(T_STRING, 0); } diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 879141d1a139e..e37ec16653048 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -2285,6 +2285,9 @@ ZEND_API int ZEND_FASTCALL zend_compare(zval *op1, zval *op2) /* {{{ */ case TYPE_PAIR(IS_TRUE, IS_NULL): return 1; + case TYPE_PAIR(IS_ATOM, IS_ATOM): + return Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2) ? 0 : (Z_ATOM_ID_P(op1) < Z_ATOM_ID_P(op2) ? -1 : 1); + case TYPE_PAIR(IS_STRING, IS_STRING): if (Z_STR_P(op1) == Z_STR_P(op2)) { return 0; @@ -2415,6 +2418,8 @@ ZEND_API bool ZEND_FASTCALL zend_is_identical(const zval *op1, const zval *op2) return 1; case IS_LONG: return (Z_LVAL_P(op1) == Z_LVAL_P(op2)); + case IS_ATOM: + return (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); case IS_RESOURCE: return (Z_RES_P(op1) == Z_RES_P(op2)); case IS_DOUBLE: diff --git a/Zend/zend_string.h b/Zend/zend_string.h index e9e2b947a6c91..bbe85bf3a18a4 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -606,6 +606,7 @@ EMPTY_SWITCH_DEFAULT_CASE() _(ZEND_STR_INTEGER, "integer") \ _(ZEND_STR_DOUBLE, "double") \ _(ZEND_STR_ARRAY, "array") \ + _(ZEND_STR_ATOM, "atom") \ _(ZEND_STR_RESOURCE, "resource") \ _(ZEND_STR_CLOSED_RESOURCE, "resource (closed)") \ _(ZEND_STR_NAME, "name") \ diff --git a/Zend/zend_type_info.h b/Zend/zend_type_info.h index eeab7bf0431da..bac167c43240a 100644 --- a/Zend/zend_type_info.h +++ b/Zend/zend_type_info.h @@ -32,7 +32,8 @@ #define MAY_BE_ARRAY (1 << IS_ARRAY) #define MAY_BE_OBJECT (1 << IS_OBJECT) #define MAY_BE_RESOURCE (1 << IS_RESOURCE) -#define MAY_BE_ANY (MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE) +#define MAY_BE_ATOM (1 << IS_ATOM) +#define MAY_BE_ANY (MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_ATOM) #define MAY_BE_REF (1 << IS_REFERENCE) /* may be reference */ /* These are used in zend_type, but not for type inference. @@ -53,6 +54,7 @@ #define MAY_BE_ARRAY_OF_ARRAY (MAY_BE_ARRAY << MAY_BE_ARRAY_SHIFT) #define MAY_BE_ARRAY_OF_OBJECT (MAY_BE_OBJECT << MAY_BE_ARRAY_SHIFT) #define MAY_BE_ARRAY_OF_RESOURCE (MAY_BE_RESOURCE << MAY_BE_ARRAY_SHIFT) +#define MAY_BE_ARRAY_OF_ATOM (MAY_BE_ATOM << MAY_BE_ARRAY_SHIFT) #define MAY_BE_ARRAY_OF_ANY (MAY_BE_ANY << MAY_BE_ARRAY_SHIFT) #define MAY_BE_ARRAY_OF_REF (MAY_BE_REF << MAY_BE_ARRAY_SHIFT) diff --git a/Zend/zend_types.h b/Zend/zend_types.h index f839cec3b3667..b8a8a6eaedd02 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -326,6 +326,7 @@ typedef union _zend_value { void *ptr; zend_class_entry *ce; zend_function *func; + uint32_t atom_id; /* atom identifier */ struct { uint32_t w1; uint32_t w2; @@ -609,25 +610,26 @@ struct _zend_ast_ref { #define IS_RESOURCE 9 #define IS_REFERENCE 10 #define IS_CONSTANT_AST 11 /* Constant expressions */ +#define IS_ATOM 12 /* Atom type */ /* Fake types used only for type hinting. * These are allowed to overlap with the types below. */ -#define IS_CALLABLE 12 -#define IS_ITERABLE 13 -#define IS_VOID 14 -#define IS_STATIC 15 -#define IS_MIXED 16 -#define IS_NEVER 17 +#define IS_CALLABLE 13 +#define IS_ITERABLE 14 +#define IS_VOID 15 +#define IS_STATIC 16 +#define IS_MIXED 17 +#define IS_NEVER 18 /* internal types */ -#define IS_INDIRECT 12 -#define IS_PTR 13 -#define IS_ALIAS_PTR 14 -#define _IS_ERROR 15 +#define IS_INDIRECT 13 +#define IS_PTR 14 +#define IS_ALIAS_PTR 15 +#define _IS_ERROR 16 /* used for casts */ -#define _IS_BOOL 18 -#define _IS_NUMBER 19 +#define _IS_BOOL 19 +#define _IS_NUMBER 20 /* guard flags */ #define ZEND_GUARD_PROPERTY_GET (1<<0) @@ -1045,6 +1047,9 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { #define Z_PTR(zval) (zval).value.ptr #define Z_PTR_P(zval_p) Z_PTR(*(zval_p)) +#define Z_ATOM_ID(zval) (zval).value.atom_id +#define Z_ATOM_ID_P(zval_p) Z_ATOM_ID(*(zval_p)) + #define ZVAL_UNDEF(z) do { \ Z_TYPE_INFO_P(z) = IS_UNDEF; \ } while (0) @@ -1261,6 +1266,12 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { Z_TYPE_INFO_P(z) = IS_ALIAS_PTR; \ } while (0) +#define ZVAL_ATOM(z, id) do { \ + zval *__z = (z); \ + Z_ATOM_ID_P(__z) = (id); \ + Z_TYPE_INFO_P(__z) = IS_ATOM; \ + } while (0) + #define ZVAL_ERROR(z) do { \ Z_TYPE_INFO_P(z) = _IS_ERROR; \ } while (0) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 162b7e84cefbe..16ae4a59ea81f 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6282,6 +6282,9 @@ ZEND_VM_C_LABEL(num_index): zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); ZEND_VM_C_GOTO(num_index); + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + ZEND_VM_C_GOTO(str_index); } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -6792,6 +6795,9 @@ ZEND_VM_C_LABEL(num_index_dim): zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); ZEND_VM_C_GOTO(num_index_dim); + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + ZEND_VM_C_GOTO(str_index_dim); } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -10041,6 +10047,18 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL|ZEND_IS_IDENTICAL, (op1_info == MAY_ ZEND_VM_SMART_BRANCH(result, 0); } +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL|ZEND_IS_IDENTICAL, (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM), ZEND_IS_EQUAL_ATOM, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE)) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH(result, 0); +} + ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_NOT_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE)) { USE_OPLINE @@ -10053,6 +10071,18 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info ZEND_VM_SMART_BRANCH(result, 0); } +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM), ZEND_IS_NOT_EQUAL_ATOM, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE)) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH(result, 0); +} + ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_NOT_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE)) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 902e254ff2424..06f8fcd848294 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -7832,6 +7832,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -10219,6 +10222,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -11144,6 +11150,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_U zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -12710,6 +12719,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -13877,6 +13889,42 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_NONE(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPZ(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -13913,6 +13961,42 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_ ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_NONE(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPZ(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = RT_CONSTANT(opline, opline->op2); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -14783,6 +14867,42 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_NONE(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPZ(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) == Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -14819,6 +14939,42 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_ ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_NONE(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPZ(result, 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + op1 = EX_VAR(opline->op1.var); + op2 = EX_VAR(opline->op2.var); + result = (Z_ATOM_ID_P(op1) != Z_ATOM_ID_P(op2)); + ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20887,6 +21043,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -21327,6 +21486,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -21784,6 +21946,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -22184,6 +22349,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -26095,6 +26263,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -26187,6 +26358,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDL zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -28612,6 +28786,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -28704,6 +28881,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HAND zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -30686,6 +30866,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -33061,6 +33244,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -33153,6 +33339,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER( zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -45274,6 +45463,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -45366,6 +45558,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -49027,6 +49222,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -49119,6 +49317,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDL zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -50991,6 +51192,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -54622,6 +54826,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + str = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); @@ -54714,6 +54921,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(Z zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; + } else if (Z_TYPE_P(offset) == IS_ATOM) { + key = zend_atom_name(Z_ATOM_ID_P(offset)); + goto str_index_dim; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); @@ -58136,6 +58346,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, @@ -58211,6 +58496,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL, @@ -60399,6 +60759,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST): VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60414,6 +60789,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST): VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60639,6 +61029,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ): + VM_TRACE(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV): VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60654,6 +61059,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV): VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -67323,6 +67743,81 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, @@ -67398,6 +67893,81 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER, @@ -67882,7 +68452,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3486, + 3636, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -67916,7 +68486,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3486, + 3636, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -68047,52 +68617,52 @@ void zend_vm_init(void) 2573 | SPEC_RULE_OBSERVER, 2575, 2576, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, + 3636, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -68340,8 +68910,13 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t break; } spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + } else if (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM) { + if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { + break; + } + spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3260 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -68352,14 +68927,19 @@ 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 = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + } else if (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM) { + if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { + break; + } + spec = 3110 | 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 = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3185 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3265 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -68376,6 +68956,11 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t break; } spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + } else if (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM) { + if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { + break; + } + spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -68386,12 +68971,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 = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + } else if (op1_info == MAY_BE_ATOM && op2_info == MAY_BE_ATOM) { + if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { + break; + } + spec = 3110 | 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 = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3185 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -68399,12 +68989,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 = 3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3270 | 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 = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -68412,49 +69002,49 @@ 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 = 3270 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3420 | 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 = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3495 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3432 | SPEC_RULE_OP1; + spec = 3582 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3437 | SPEC_RULE_OP1; + spec = 3587 | 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 = 3442 | SPEC_RULE_OP1; + spec = 3592 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3570 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3572 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3424 | SPEC_RULE_RETVAL; + spec = 3574 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3426 | SPEC_RULE_RETVAL; + spec = 3576 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3428; + spec = 3578; } else if (op1_info == MAY_BE_LONG) { - spec = 3429; + spec = 3579; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3430; + spec = 3580; } else if (op1_info == MAY_BE_LONG) { - spec = 3431; + spec = 3581; } break; case ZEND_JMP: @@ -68474,17 +69064,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3482; + spec = 3632; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3477 | SPEC_RULE_OP1; + spec = 3627 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3484 | SPEC_RULE_RETVAL; + spec = 3634 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -68492,17 +69082,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 = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3597 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3483; + spec = 3633; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3472 | SPEC_RULE_OP1; + spec = 3622 | SPEC_RULE_OP1; } break; case ZEND_COUNT: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 7f3a3cb5de260..f73e658f2641e 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1567,307 +1567,379 @@ _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3114, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3119, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3420, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3425, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3426, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3427, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3428, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3429, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3430, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3431, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3433, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3436, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3438, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3441, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3443, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3446, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3476, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3481, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3482, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3483, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3484, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3485, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3485+1, ZEND_NULL) + _(2975, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(2976, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2977, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2978, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2981, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(2982, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2983, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2987, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(2988, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2989, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2990, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(2991, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2992, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2993, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(2994, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2995, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2996, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(2997, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2998, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3003, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3004, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3020, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(3021, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3022, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3023, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3026, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3027, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3028, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3032, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3033, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3034, ZEND_IS_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3052, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3056, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3057, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3058, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3062, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3063, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3064, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3065, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3066, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3067, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3068, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3069, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3070, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3071, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3072, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3073, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3078, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3079, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3095, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3096, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3097, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3098, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3101, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3102, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3103, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3107, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3108, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3109, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3125, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(3126, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3127, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3128, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3129, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3131, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3132, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3133, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3137, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3138, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3139, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3140, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(3141, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3142, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3143, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3144, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3145, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3146, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3147, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3148, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3152, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3153, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3154, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3170, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST) \ + _(3171, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3172, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3173, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3174, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3175, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3176, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3177, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3178, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3182, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV) \ + _(3183, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3184, ZEND_IS_NOT_EQUAL_ATOM_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3200, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3201, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3202, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3213, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3214, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3216, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3217, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3219, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3220, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3221, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3223, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3227, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3228, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3229, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3245, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3246, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3247, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3249, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3250, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3251, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3252, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3253, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3257, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3258, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3259, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3260, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3264, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3265, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3269, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3273, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3274, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3275, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3276, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3277, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3278, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3282, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3283, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3284, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3291, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3292, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3298, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3299, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3301, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3302, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3306, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3307, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3308, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3331, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3332, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3333, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3334, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3335, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3336, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3337, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3338, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3342, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3343, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3344, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3348, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3349, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3350, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3351, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3352, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3353, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3357, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3358, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3359, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3363, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3364, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3365, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3366, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3367, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3372, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3373, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3374, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3375, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3376, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3377, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3378, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3379, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3380, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3381, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3382, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3383, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3405, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3406, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3407, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3408, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3409, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3410, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3411, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3412, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3413, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3417, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3418, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3419, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3423, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3425, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3427, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3438, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3439, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3440, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3441, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3442, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3447, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3448, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3449, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3450, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3451, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3452, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3453, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3454, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3455, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3456, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3457, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3458, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3480, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3481, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3482, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3483, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3484, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3485, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3486, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3487, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3488, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3492, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3493, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3494, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3498, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3499, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3500, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3501, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3502, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3513, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3514, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3515, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3516, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3517, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3522, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3523, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3524, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3525, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3526, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3527, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3528, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3529, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3530, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3531, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3532, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3533, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3555, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3556, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3557, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3558, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3559, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3560, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3561, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3562, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3563, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3567, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3568, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3569, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3570, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3571, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3572, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3573, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3574, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3575, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3576, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3577, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3578, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3579, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3580, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3581, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3582, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3583, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3584, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3586, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3587, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3588, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3589, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3591, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3592, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3593, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3594, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3596, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3598, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3599, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3601, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3602, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3603, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3604, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3606, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3607, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3608, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3609, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3611, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3617, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3618, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3619, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3621, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3624, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3626, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3629, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3631, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3632, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3633, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3634, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3635, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3635+1, ZEND_NULL) diff --git a/configure.ac b/configure.ac index 01d9ded69b920..32eae9a2dc17c 100644 --- a/configure.ac +++ b/configure.ac @@ -1711,6 +1711,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([ Optimizer/zend_optimizer.c Optimizer/zend_ssa.c zend_alloc.c + zend_atom.c zend_API.c zend_ast.c zend_atomic.c diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php index b6533d8dc20e8..bd4acf86d5925 100644 --- a/ext/standard/basic_functions.stub.php +++ b/ext/standard/basic_functions.stub.php @@ -3597,6 +3597,14 @@ function gettype(mixed $value): string {} */ function get_debug_type(mixed $value): string {} +function atom(string $name): atom {} + +function string(atom $atom): string {} + +function get_defined_atoms(): array {} + +function atom_exists(string $name): bool {} + function settype(mixed &$var, string $type): bool {} /** @@ -3672,6 +3680,11 @@ function is_string(mixed $value): bool {} */ function is_array(mixed $value): bool {} +/** + * @compile-time-eval + */ +function is_atom(mixed $value): bool {} + /** * @compile-time-eval */ diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h index d35377c900735..b346dd7159057 100644 --- a/ext/standard/basic_functions_arginfo.h +++ b/ext/standard/basic_functions_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 824ccb41163307bd0fad452b705a8222b6f42d09 */ + * Stub hash: b319a1197f131279574718e1308146a106dd55a2 */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0) ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0) @@ -2007,6 +2007,20 @@ ZEND_END_ARG_INFO() #define arginfo_get_debug_type arginfo_gettype +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_atom, 0, 1, IS_ATOM, 0) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_string, 0, 1, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, atom, IS_ATOM, 0) +ZEND_END_ARG_INFO() + +#define arginfo_get_defined_atoms arginfo_ob_list_handlers + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_atom_exists, 0, 1, _IS_BOOL, 0) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) +ZEND_END_ARG_INFO() + ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_settype, 0, 2, _IS_BOOL, 0) ZEND_ARG_TYPE_INFO(1, var, IS_MIXED, 0) ZEND_ARG_TYPE_INFO(0, type, IS_STRING, 0) @@ -2051,6 +2065,8 @@ ZEND_END_ARG_INFO() #define arginfo_is_array arginfo_boolval +#define arginfo_is_atom arginfo_boolval + #define arginfo_is_object arginfo_boolval #define arginfo_is_scalar arginfo_boolval @@ -2823,6 +2839,10 @@ ZEND_FUNCTION(stream_set_timeout); #endif ZEND_FUNCTION(gettype); ZEND_FUNCTION(get_debug_type); +ZEND_FUNCTION(atom); +ZEND_FUNCTION(string); +ZEND_FUNCTION(get_defined_atoms); +ZEND_FUNCTION(atom_exists); ZEND_FUNCTION(settype); ZEND_FUNCTION(intval); ZEND_FUNCTION(floatval); @@ -2836,6 +2856,7 @@ ZEND_FUNCTION(is_float); ZEND_FUNCTION(is_numeric); ZEND_FUNCTION(is_string); ZEND_FUNCTION(is_array); +ZEND_FUNCTION(is_atom); ZEND_FUNCTION(is_object); ZEND_FUNCTION(is_scalar); ZEND_FUNCTION(is_callable); @@ -3431,6 +3452,10 @@ static const zend_function_entry ext_functions[] = { #endif ZEND_RAW_FENTRY("gettype", zif_gettype, arginfo_gettype, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_RAW_FENTRY("get_debug_type", zif_get_debug_type, arginfo_get_debug_type, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) + ZEND_FE(atom, arginfo_atom) + ZEND_FE(string, arginfo_string) + ZEND_FE(get_defined_atoms, arginfo_get_defined_atoms) + ZEND_FE(atom_exists, arginfo_atom_exists) ZEND_FE(settype, arginfo_settype) ZEND_RAW_FENTRY("intval", zif_intval, arginfo_intval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_RAW_FENTRY("floatval", zif_floatval, arginfo_floatval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) @@ -3448,6 +3473,7 @@ static const zend_function_entry ext_functions[] = { ZEND_RAW_FENTRY("is_numeric", zif_is_numeric, arginfo_is_numeric, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_is_numeric, NULL) ZEND_RAW_FENTRY("is_string", zif_is_string, arginfo_is_string, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_RAW_FENTRY("is_array", zif_is_array, arginfo_is_array, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) + ZEND_RAW_FENTRY("is_atom", zif_is_atom, arginfo_is_atom, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_RAW_FENTRY("is_object", zif_is_object, arginfo_is_object, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_RAW_FENTRY("is_scalar", zif_is_scalar, arginfo_is_scalar, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL) ZEND_FE(is_callable, arginfo_is_callable) diff --git a/ext/standard/type.c b/ext/standard/type.c index 4557014ff5a33..a1323cd617943 100644 --- a/ext/standard/type.c +++ b/ext/standard/type.c @@ -15,6 +15,7 @@ */ #include "php.h" +#include "zend_atom.h" /* {{{ Returns the type of the variable */ PHP_FUNCTION(gettype) @@ -59,6 +60,8 @@ PHP_FUNCTION(get_debug_type) RETURN_INTERNED_STR(ZSTR_KNOWN(ZEND_STR_STRING)); case IS_ARRAY: RETURN_INTERNED_STR(ZSTR_KNOWN(ZEND_STR_ARRAY)); + case IS_ATOM: + RETURN_INTERNED_STR(ZSTR_KNOWN(ZEND_STR_ATOM)); case IS_OBJECT: if (Z_OBJ_P(arg)->ce->ce_flags & ZEND_ACC_ANON_CLASS) { name = ZSTR_VAL(Z_OBJ_P(arg)->ce->name); @@ -320,6 +323,14 @@ PHP_FUNCTION(is_array) } /* }}} */ +/* {{{ Returns true if variable is an atom + Warning: This function is special-cased by zend_compile.c and so is usually bypassed */ +PHP_FUNCTION(is_atom) +{ + php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_ATOM); +} +/* }}} */ + /* {{{ Returns true if $array is an array whose keys are all numeric, sequential, and start at 0 */ PHP_FUNCTION(array_is_list) { @@ -400,6 +411,7 @@ PHP_FUNCTION(is_scalar) case IS_DOUBLE: case IS_LONG: case IS_STRING: + case IS_ATOM: RETURN_TRUE; break; @@ -465,3 +477,78 @@ PHP_FUNCTION(is_countable) RETURN_BOOL(zend_is_countable(var)); } /* }}} */ + +/* {{{ Creates an atom from a string */ +PHP_FUNCTION(atom) +{ + zend_string *str; + uint32_t atom_id; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + + atom_id = zend_atom_create(str); + if (atom_id == ZEND_ATOM_INVALID_ID) { + zend_argument_value_error(1, "must be a valid atom identifier"); + RETURN_THROWS(); + } + + ZVAL_ATOM(return_value, atom_id); +} +/* }}} */ + +/* {{{ Converts an atom to its string representation */ +PHP_FUNCTION(string) +{ + zval *arg; + zend_string *atom_name; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(arg) + ZEND_PARSE_PARAMETERS_END(); + + if (Z_TYPE_P(arg) != IS_ATOM) { + zend_argument_type_error(1, "must be an atom, %s given", zend_zval_type_name(arg)); + RETURN_THROWS(); + } + + atom_name = zend_atom_name(Z_ATOM_ID_P(arg)); + if (!atom_name) { + zend_throw_error(NULL, "Invalid atom"); + RETURN_THROWS(); + } + + RETURN_STR_COPY(atom_name); +} +/* }}} */ + +/* {{{ Returns an array of all defined atoms */ +PHP_FUNCTION(get_defined_atoms) +{ + zval *entry; + zend_atom *atom; + + ZEND_PARSE_PARAMETERS_NONE(); + + array_init(return_value); + + ZEND_HASH_FOREACH_VAL(&atom_table, entry) { + atom = (zend_atom *)Z_PTR_P(entry); + add_next_index_str(return_value, zend_string_copy(atom->name)); + } ZEND_HASH_FOREACH_END(); +} +/* }}} */ + +/* {{{ Checks if an atom with the given name exists */ +PHP_FUNCTION(atom_exists) +{ + zend_string *name; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_BOOL(zend_atom_exists(name)); +} +/* }}} */ diff --git a/ext/standard/var.c b/ext/standard/var.c index 1c2b0eb164a1c..732ad0ca2a01e 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -30,6 +30,7 @@ #include "zend_enum.h" #include "zend_exceptions.h" #include "zend_types.h" +#include "zend_atom.h" /* }}} */ struct php_serialize_data { @@ -136,6 +137,17 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */ PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); PUTS("\"\n"); break; + case IS_ATOM: { + zend_string *atom_name = zend_atom_name(Z_ATOM_ID_P(struc)); + if (atom_name) { + php_printf("%satom(:", COMMON); + PHPWRITE(ZSTR_VAL(atom_name), ZSTR_LEN(atom_name)); + php_printf(")\n"); + } else { + php_printf("%satom(INVALID:%u)\n", COMMON, Z_ATOM_ID_P(struc)); + } + break; + } case IS_ARRAY: myht = Z_ARRVAL_P(struc); if (!(GC_FLAGS(myht) & GC_IMMUTABLE)) { @@ -331,6 +343,17 @@ PHPAPI void php_debug_zval_dump(zval *struc, int level) /* {{{ */ PUTS("\" interned\n"); } break; + case IS_ATOM: { + zend_string *atom_name = zend_atom_name(Z_ATOM_ID_P(struc)); + if (atom_name) { + php_printf("atom(:"); + PHPWRITE(ZSTR_VAL(atom_name), ZSTR_LEN(atom_name)); + php_printf(")\n"); + } else { + php_printf("atom(INVALID:%u)\n", Z_ATOM_ID_P(struc)); + } + break; + } case IS_ARRAY: myht = Z_ARRVAL_P(struc); if (!(GC_FLAGS(myht) & GC_IMMUTABLE)) { @@ -551,6 +574,16 @@ PHPAPI zend_result php_var_export_ex(zval *struc, int level, smart_str *buf) /* zend_string_free(ztmp); zend_string_free(ztmp2); break; + case IS_ATOM: { + zend_string *atom_name = zend_atom_name(Z_ATOM_ID_P(struc)); + if (atom_name) { + smart_str_appendc(buf, ':'); + smart_str_append(buf, atom_name); + } else { + smart_str_appendl(buf, "atom(INVALID)", 13); + } + break; + } case IS_ARRAY: myht = Z_ARRVAL_P(struc); if (!(GC_FLAGS(myht) & GC_IMMUTABLE)) { @@ -1109,6 +1142,21 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, php_serialize_ php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc)); return; + case IS_ATOM: { + zend_string *atom_name = zend_atom_name(Z_ATOM_ID_P(struc)); + if (atom_name) { + smart_str_appendl(buf, "A:", 2); + smart_str_append_unsigned(buf, ZSTR_LEN(atom_name)); + smart_str_appendl(buf, ":\"", 2); + smart_str_append(buf, atom_name); + smart_str_appendl(buf, "\";", 2); + } else { + /* Invalid atom, serialize as null */ + smart_str_appendl(buf, "N;", 2); + } + return; + } + case IS_OBJECT: { zend_class_entry *ce = Z_OBJCE_P(struc); bool incomplete_class; diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re index cbd457e16fdb1..c66a705bef4a0 100644 --- a/ext/standard/var_unserializer.re +++ b/ext/standard/var_unserializer.re @@ -19,6 +19,7 @@ #include "php_incomplete_class.h" #include "zend_portability.h" #include "zend_exceptions.h" +#include "zend_atom.h" /* {{{ reference-handling for unserializer: var_* */ #define VAR_ENTRIES_MAX 1018 /* 1024 - offsetof(php_unserialize_data, entries) / sizeof(void*) */ @@ -1058,6 +1059,42 @@ use_double: return 1; } +"A:" uiv ":" ["] { + size_t len, maxlen; + char *str; + + len = parse_uiv(start + 2); + maxlen = max - YYCURSOR; + if (maxlen < len) { + *p = start + 2; + return 0; + } + + str = (char*)YYCURSOR; + + YYCURSOR += len; + + if (*(YYCURSOR) != '"') { + *p = YYCURSOR; + return 0; + } + + if (*(YYCURSOR + 1) != ';') { + *p = YYCURSOR + 1; + return 0; + } + + YYCURSOR += 2; + *p = YYCURSOR; + + /* Create atom from name */ + zend_string *atom_name = zend_string_init(str, len, 0); + uint32_t atom_id = zend_atom_create(atom_name); + zend_string_release(atom_name); + ZVAL_ATOM(rval, atom_id); + return 1; +} + "S:" uiv ":" ["] { size_t len, maxlen; zend_string *str; diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index a1e131032bcfb..ed3c9a7177185 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -28,6 +28,7 @@ char *get_token_type_name(int token_type) case T_LNUMBER: return "T_LNUMBER"; case T_DNUMBER: return "T_DNUMBER"; case T_STRING: return "T_STRING"; + case T_ATOM: return "T_ATOM"; case T_NAME_FULLY_QUALIFIED: return "T_NAME_FULLY_QUALIFIED"; case T_NAME_RELATIVE: return "T_NAME_RELATIVE"; case T_NAME_QUALIFIED: return "T_NAME_QUALIFIED"; diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php index c1e1fd254dfaa..26cad657ab567 100644 --- a/ext/tokenizer/tokenizer_data.stub.php +++ b/ext/tokenizer/tokenizer_data.stub.php @@ -17,6 +17,11 @@ * @cvalue T_STRING */ const T_STRING = UNKNOWN; +/** + * @var int + * @cvalue T_ATOM + */ +const T_ATOM = UNKNOWN; /** * @var int * @cvalue T_NAME_FULLY_QUALIFIED diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h index 9c488d19f1890..1441c40133cf8 100644 --- a/ext/tokenizer/tokenizer_data_arginfo.h +++ b/ext/tokenizer/tokenizer_data_arginfo.h @@ -1,11 +1,12 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 19d25d22098f46283b517352cbb302db962b50fd */ + * Stub hash: e52d0aa7d19c83f08d0f86b14f505453fb03123e */ static void register_tokenizer_data_symbols(int module_number) { REGISTER_LONG_CONSTANT("T_LNUMBER", T_LNUMBER, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DNUMBER", T_DNUMBER, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_STRING", T_STRING, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_ATOM", T_ATOM, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NAME_FULLY_QUALIFIED", T_NAME_FULLY_QUALIFIED, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NAME_RELATIVE", T_NAME_RELATIVE, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NAME_QUALIFIED", T_NAME_QUALIFIED, CONST_PERSISTENT);