Skip to content

Use more compact representation for packed arrays. #7491

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 23 commits into from
Closed

Use more compact representation for packed arrays. #7491

Show file tree
Hide file tree
Changes from 21 commits
Commits
Show all changes
23 commits
Select commit Hold shift + click to select a range
320ad87
Use more compact representation for packed arrays.
dstogov Sep 14, 2021
63f76a6
Fixed memory leaks in ext/standard/tests/array/shuffle_basic2.phpt
dstogov Sep 14, 2021
ebda1e8
Move condition
dstogov Sep 20, 2021
6b1e401
Revert packed array related changes
dstogov Oct 26, 2021
d5c69ed
Merge branch 'master' into packed_ht
dstogov Oct 26, 2021
ebbde91
ws
dstogov Oct 26, 2021
ea245bd
Packed arrays can't contain IS_INDIRECT elements
dstogov Oct 26, 2021
1b30fd9
Use specific array/hash/packed iterators where possible
dstogov Oct 27, 2021
319383d
Use general hash/packed iterators
dstogov Oct 27, 2021
6092d79
Micro-optimization of genral hash/packed array iteration macros ZEND_…
dstogov Oct 28, 2021
718042a
Fixed ARM64 JIT
dstogov Oct 28, 2021
8e33bf8
Sparate ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_EL…
dstogov Oct 29, 2021
7c6f54e
Rename ZEND_HASH_*_FOREACH_* iteration macros
dstogov Nov 1, 2021
bf21211
Merge branch 'master' into packed_ht
dstogov Nov 1, 2021
bf4bf22
Fixed typo
dstogov Nov 1, 2021
a9f8192
Fixed comment
dstogov Nov 2, 2021
7b81cde
Remove redundand HT_IS_PACKED asserts and add a missed one
dstogov Nov 2, 2021
570fadd
Use specialized packed/hash iterators
dstogov Nov 2, 2021
cc3b921
Use general hash iteration macros
dstogov Nov 2, 2021
361eb14
Attempt to fix Windows build
dstogov Nov 2, 2021
bf316ba
Use genral macro "ZEND_HASH_ELEMENT(ht, i)" instead of "HT_IS_PACKED(…
dstogov Nov 2, 2021
ff48182
Use specialized packed iterator. (We checked for !HT_IS_CACHE above).
dstogov Nov 3, 2021
9bbaf67
Use general hash/packed iteratr or HT_IS_CACHE check
dstogov Nov 3, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion Zend/Optimizer/sccp.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -767,7 +767,7 @@ static inline zend_result ct_eval_in_array(zval *result, uint32_t extended_value
zval key_tmp;

res = 0;
ZEND_HASH_FOREACH_STR_KEY(ht, key) {
ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
ZVAL_STR(&key_tmp, key);
if (zend_compare(op1, &key_tmp) == 0) {
res = 1;
Expand Down
10 changes: 5 additions & 5 deletions Zend/Optimizer/zend_optimizer.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1360,15 +1360,15 @@ void zend_foreach_op_array(zend_script *script, zend_op_array_func_t func, void

zend_foreach_op_array_helper(&script->main_op_array, func, context);

ZEND_HASH_FOREACH_PTR(&script->function_table, op_array) {
ZEND_HASH_MAP_FOREACH_PTR(&script->function_table, op_array) {
zend_foreach_op_array_helper(op_array, func, context);
} ZEND_HASH_FOREACH_END();

ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
continue;
}
ZEND_HASH_FOREACH_PTR(&ce->function_table, op_array) {
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, op_array) {
if (op_array->scope == ce
&& op_array->type == ZEND_USER_FUNCTION
&& !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
Expand Down Expand Up @@ -1516,11 +1516,11 @@ ZEND_API void zend_optimize_script(zend_script *script, zend_long optimization_l
}
}

ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
continue;
}
ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
if (op_array->scope != ce && op_array->type == ZEND_USER_FUNCTION) {
zend_op_array *orig_op_array =
zend_hash_find_ptr(&op_array->scope->function_table, name);
Expand Down
32 changes: 16 additions & 16 deletions Zend/zend_API.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1285,7 +1285,7 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties) /* {{{ */
zval *value;

EG(fake_scope) = Z_OBJCE_P(obj);
ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, value) {
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(properties, key, value) {
if (key) {
write_property(zobj, key, value, NULL);
}
Expand Down Expand Up @@ -1321,7 +1321,7 @@ ZEND_API HashTable *zend_separate_class_constants_table(zend_class_entry *class_
zend_hash_init(constants_table, zend_hash_num_elements(&class_type->constants_table), NULL, NULL, 0);
zend_hash_extend(constants_table, zend_hash_num_elements(&class_type->constants_table), 0);

ZEND_HASH_FOREACH_STR_KEY_PTR(&class_type->constants_table, key, c) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&class_type->constants_table, key, c) {
if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
new_c = zend_arena_alloc(&CG(arena), sizeof(zend_class_constant));
memcpy(new_c, c, sizeof(zend_class_constant));
Expand Down Expand Up @@ -1409,7 +1409,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
} else {
constants_table = &class_type->constants_table;
}
ZEND_HASH_FOREACH_PTR(constants_table, c) {
ZEND_HASH_MAP_FOREACH_PTR(constants_table, c) {
if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
val = &c->value;
if (UNEXPECTED(zval_update_constant_ex(val, c->ce) != SUCCESS)) {
Expand Down Expand Up @@ -1461,7 +1461,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
}

if (class_type->default_static_members_count) {
ZEND_HASH_FOREACH_PTR(&class_type->properties_info, prop_info) {
ZEND_HASH_MAP_FOREACH_PTR(&class_type->properties_info, prop_info) {
if (prop_info->flags & ZEND_ACC_STATIC) {
val = static_members_table + prop_info->offset;
if (Z_TYPE_P(val) == IS_CONSTANT_AST
Expand Down Expand Up @@ -1526,7 +1526,7 @@ ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properti
zend_string *key;
zend_property_info *property_info;

ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, prop) {
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(properties, key, prop) {
property_info = zend_get_property_info(object->ce, key, 1);
if (property_info != ZEND_WRONG_PROPERTY_INFO &&
property_info &&
Expand Down Expand Up @@ -1558,7 +1558,7 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties)
zend_long h;
zend_property_info *property_info;

ZEND_HASH_FOREACH_KEY_VAL(properties, h, key, prop) {
ZEND_HASH_MAP_FOREACH_KEY_VAL(properties, h, key, prop) {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think this may not be true, e.g. the usage at

php-src/ext/hash/hash.c

Line 1558 in 4239ec5

object_properties_load(&hash->std, Z_ARRVAL_P(members_zv));
can probably be a packed array depending on what gets passed to unserialize()?

Copy link
Contributor

@TysonAndre TysonAndre Nov 14, 2021 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

EDIT: I see this was undone so no concerns, agree it may be packed

can probably be a packed array depending on what gets passed to unserialize()?

/* {{{ */
PHP_METHOD(SplDoublyLinkedList, __unserialize) {
	spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
	HashTable *data;
	zval *flags_zv, *storage_zv, *members_zv, *elem;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
		RETURN_THROWS();
	}

	flags_zv = zend_hash_index_find(data, 0);
	storage_zv = zend_hash_index_find(data, 1);
	members_zv = zend_hash_index_find(data, 2);
	if (!flags_zv || !storage_zv || !members_zv ||
			Z_TYPE_P(flags_zv) != IS_LONG || Z_TYPE_P(storage_zv) != IS_ARRAY ||
			Z_TYPE_P(members_zv) != IS_ARRAY) {
		zend_throw_exception(spl_ce_UnexpectedValueException,
			"Incomplete or ill-typed serialization data", 0);
		RETURN_THROWS();
	}

	intern->flags = (int) Z_LVAL_P(flags_zv);

	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(storage_zv), elem) {
		spl_ptr_llist_push(intern->llist, elem);
	} ZEND_HASH_FOREACH_END();

	object_properties_load(&intern->std, Z_ARRVAL_P(members_zv));
} /* }}} */

Also, userland code can directly call functions such as $splDoubleLinkedList->__unserialize($data) with any array value as $data[2] getting passed as properties to object_properties_load.

  • A separate question is whether that should be detected and forbidden if the collection is already initialized/constructed. The Deque RFC implementation forbids that, for example

And third party serializers may not have the same restrictions on arrays in the future, even if they currently do (igbinary currently does convert non-empty packed arrays to hashes while unserializing)

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@ TysonAndre this chunk is reverted. I didn't understand, do you still see some problem here?

if (key) {
if (ZSTR_VAL(key)[0] == '\0') {
const char *class_name, *prop_name;
Expand Down Expand Up @@ -2243,7 +2243,7 @@ ZEND_API void zend_collect_module_handlers(void) /* {{{ */
int class_count = 0;

/* Collect extensions with request startup/shutdown handlers */
ZEND_HASH_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_FOREACH_PTR(&module_registry, module) {
if (module->request_startup_func) {
startup_count++;
}
Expand All @@ -2266,7 +2266,7 @@ ZEND_API void zend_collect_module_handlers(void) /* {{{ */
module_post_deactivate_handlers[post_deactivate_count] = NULL;
startup_count = 0;

ZEND_HASH_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_FOREACH_PTR(&module_registry, module) {
if (module->request_startup_func) {
module_request_startup_handlers[startup_count++] = module;
}
Expand All @@ -2279,7 +2279,7 @@ ZEND_API void zend_collect_module_handlers(void) /* {{{ */
} ZEND_HASH_FOREACH_END();

/* Collect internal classes with static members */
ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
if (ce->type == ZEND_INTERNAL_CLASS &&
ce->default_static_members_count > 0) {
class_count++;
Expand All @@ -2292,7 +2292,7 @@ ZEND_API void zend_collect_module_handlers(void) /* {{{ */
class_cleanup_handlers[class_count] = NULL;

if (class_count) {
ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
if (ce->type == ZEND_INTERNAL_CLASS &&
ce->default_static_members_count > 0) {
class_cleanup_handlers[--class_count] = ce;
Expand Down Expand Up @@ -2981,7 +2981,7 @@ ZEND_API void zend_deactivate_modules(void) /* {{{ */
if (EG(full_tables_cleanup)) {
zend_module_entry *module;

ZEND_HASH_REVERSE_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_REVERSE_FOREACH_PTR(&module_registry, module) {
if (module->request_shutdown_func) {
zend_try {
module->request_shutdown_func(module->type, module->module_number);
Expand Down Expand Up @@ -3009,20 +3009,20 @@ ZEND_API void zend_post_deactivate_modules(void) /* {{{ */
zval *zv;
zend_string *key;

ZEND_HASH_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_FOREACH_PTR(&module_registry, module) {
if (module->post_deactivate_func) {
module->post_deactivate_func();
}
} ZEND_HASH_FOREACH_END();
ZEND_HASH_REVERSE_FOREACH_STR_KEY_VAL(&module_registry, key, zv) {
ZEND_HASH_MAP_REVERSE_FOREACH_STR_KEY_VAL(&module_registry, key, zv) {
module = Z_PTR_P(zv);
if (module->type != MODULE_TEMPORARY) {
break;
}
module_destructor(module);
free(module);
zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END_DEL();
} ZEND_HASH_MAP_FOREACH_END_DEL();
} else {
zend_module_entry **p = module_post_deactivate_handlers;

Expand Down Expand Up @@ -3267,14 +3267,14 @@ ZEND_API zend_result zend_disable_class(const char *class_name, size_t class_nam
INIT_CLASS_ENTRY_INIT_METHODS((*disabled_class), disabled_class_new);
disabled_class->create_object = display_disabled_class;

ZEND_HASH_FOREACH_PTR(&disabled_class->function_table, fn) {
ZEND_HASH_MAP_FOREACH_PTR(&disabled_class->function_table, fn) {
if ((fn->common.fn_flags & (ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_HAS_TYPE_HINTS)) &&
fn->common.scope == disabled_class) {
zend_free_internal_arg_info(&fn->internal_function);
}
} ZEND_HASH_FOREACH_END();
zend_hash_clean(&disabled_class->function_table);
ZEND_HASH_FOREACH_PTR(&disabled_class->properties_info, prop) {
ZEND_HASH_MAP_FOREACH_PTR(&disabled_class->properties_info, prop) {
if (prop->ce == disabled_class) {
zend_string_release(prop->name);
zend_type_release(prop->type, /* persistent */ 1);
Expand Down
6 changes: 3 additions & 3 deletions Zend/zend_attributes.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -78,7 +78,7 @@ static zend_attribute *get_attribute(HashTable *attributes, zend_string *lcname,
if (attributes) {
zend_attribute *attr;

ZEND_HASH_FOREACH_PTR(attributes, attr) {
ZEND_HASH_PACKED_FOREACH_PTR(attributes, attr) {
if (attr->offset == offset && zend_string_equals(attr->lcname, lcname)) {
return attr;
}
Expand All @@ -93,7 +93,7 @@ static zend_attribute *get_attribute_str(HashTable *attributes, const char *str,
if (attributes) {
zend_attribute *attr;

ZEND_HASH_FOREACH_PTR(attributes, attr) {
ZEND_HASH_PACKED_FOREACH_PTR(attributes, attr) {
if (attr->offset == offset && ZSTR_LEN(attr->lcname) == len) {
if (0 == memcmp(ZSTR_VAL(attr->lcname), str, len)) {
return attr;
Expand Down Expand Up @@ -173,7 +173,7 @@ ZEND_API bool zend_is_attribute_repeated(HashTable *attributes, zend_attribute *
{
zend_attribute *other;

ZEND_HASH_FOREACH_PTR(attributes, other) {
ZEND_HASH_PACKED_FOREACH_PTR(attributes, other) {
if (other != attr && other->offset == attr->offset) {
if (zend_string_equals(other->lcname, attr->lcname)) {
return 1;
Expand Down
24 changes: 12 additions & 12 deletions Zend/zend_builtin_functions.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -669,7 +669,7 @@ static void add_class_vars(zend_class_entry *scope, zend_class_entry *ce, bool s
zend_string *key;
zval *default_properties_table = CE_DEFAULT_PROPERTIES_TABLE(ce);

ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) {
if (((prop_info->flags & ZEND_ACC_PROTECTED) &&
!zend_check_protected(prop_info->ce, scope)) ||
((prop_info->flags & ZEND_ACC_PRIVATE) &&
Expand Down Expand Up @@ -758,7 +758,7 @@ ZEND_FUNCTION(get_object_vars)
} else {
array_init_size(return_value, zend_hash_num_elements(properties));

ZEND_HASH_FOREACH_KEY_VAL(properties, num_key, key, value) {
ZEND_HASH_MAP_FOREACH_KEY_VAL(properties, num_key, key, value) {
bool is_dynamic = 1;
if (Z_TYPE_P(value) == IS_INDIRECT) {
value = Z_INDIRECT_P(value);
Expand Down Expand Up @@ -838,7 +838,7 @@ ZEND_FUNCTION(get_class_methods)
array_init(return_value);
scope = zend_get_executed_scope();

ZEND_HASH_FOREACH_PTR(&ce->function_table, mptr) {
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, mptr) {
if ((mptr->common.fn_flags & ZEND_ACC_PUBLIC)
|| (scope &&
(((mptr->common.fn_flags & ZEND_ACC_PROTECTED) &&
Expand Down Expand Up @@ -1094,7 +1094,7 @@ ZEND_FUNCTION(get_included_files)
ZEND_PARSE_PARAMETERS_NONE();

array_init(return_value);
ZEND_HASH_FOREACH_STR_KEY(&EG(included_files), entry) {
ZEND_HASH_MAP_FOREACH_STR_KEY(&EG(included_files), entry) {
if (entry) {
add_next_index_str(return_value, zend_string_copy(entry));
}
Expand Down Expand Up @@ -1248,7 +1248,7 @@ static inline void get_declared_class_impl(INTERNAL_FUNCTION_PARAMETERS, int fla
array_init(return_value);
zend_hash_real_init_packed(Z_ARRVAL_P(return_value));
ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
ZEND_HASH_FOREACH_STR_KEY_VAL(EG(class_table), key, zv) {
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EG(class_table), key, zv) {
ce = Z_PTR_P(zv);
if ((ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT)) == flags
&& key
Expand Down Expand Up @@ -1309,7 +1309,7 @@ ZEND_FUNCTION(get_defined_functions)
array_init(&user);
array_init(return_value);

ZEND_HASH_FOREACH_STR_KEY_PTR(EG(function_table), key, func) {
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(EG(function_table), key, func) {
if (key && ZSTR_VAL(key)[0] != 0) {
if (func->type == ZEND_INTERNAL_FUNCTION) {
add_next_index_str(&internal, zend_string_copy(key));
Expand Down Expand Up @@ -1455,7 +1455,7 @@ ZEND_FUNCTION(get_loaded_extensions)
} else {
zend_module_entry *module;

ZEND_HASH_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_FOREACH_PTR(&module_registry, module) {
add_next_index_string(return_value, module->name);
} ZEND_HASH_FOREACH_END();
}
Expand Down Expand Up @@ -1485,13 +1485,13 @@ ZEND_FUNCTION(get_defined_constants)
module_names = emalloc((zend_hash_num_elements(&module_registry) + 2) * sizeof(char *));

module_names[0] = "internal";
ZEND_HASH_FOREACH_PTR(&module_registry, module) {
ZEND_HASH_MAP_FOREACH_PTR(&module_registry, module) {
module_names[module->module_number] = (char *)module->name;
i++;
} ZEND_HASH_FOREACH_END();
module_names[i] = "user";

ZEND_HASH_FOREACH_PTR(EG(zend_constants), val) {
ZEND_HASH_MAP_FOREACH_PTR(EG(zend_constants), val) {
if (!val->name) {
/* skip special constants */
continue;
Expand Down Expand Up @@ -1521,7 +1521,7 @@ ZEND_FUNCTION(get_defined_constants)
zend_constant *constant;
zval const_val;

ZEND_HASH_FOREACH_PTR(EG(zend_constants), constant) {
ZEND_HASH_MAP_FOREACH_PTR(EG(zend_constants), constant) {
if (!constant->name) {
/* skip special constants */
continue;
Expand Down Expand Up @@ -1606,7 +1606,7 @@ static void debug_backtrace_get_args(zend_execute_data *call, zval *arg_array) /
zend_string *name;
zval *arg;
SEPARATE_ARRAY(arg_array);
ZEND_HASH_FOREACH_STR_KEY_VAL(call->extra_named_params, name, arg) {
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(call->extra_named_params, name, arg) {
ZVAL_DEREF(arg);
Z_TRY_ADDREF_P(arg);
zend_hash_add_new(Z_ARRVAL_P(arg_array), name, arg);
Expand Down Expand Up @@ -1902,7 +1902,7 @@ ZEND_FUNCTION(get_extension_funcs)
array = 0;
}

ZEND_HASH_FOREACH_PTR(CG(function_table), zif) {
ZEND_HASH_MAP_FOREACH_PTR(CG(function_table), zif) {
if (zif->common.type == ZEND_INTERNAL_FUNCTION
&& zif->internal_function.module == module) {
if (!array) {
Expand Down
2 changes: 1 addition & 1 deletion Zend/zend_closures.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -560,7 +560,7 @@ static HashTable *zend_closure_get_debug_info(zend_object *object, int *is_temp)

array_init(&val);

ZEND_HASH_FOREACH_STR_KEY_VAL(static_variables, key, var) {
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(static_variables, key, var) {
zval copy;

if (Z_TYPE_P(var) == IS_CONSTANT_AST) {
Expand Down
10 changes: 5 additions & 5 deletions Zend/zend_compile.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1728,7 +1728,7 @@ ZEND_API void zend_activate_auto_globals(void) /* {{{ */
{
zend_auto_global *auto_global;

ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
ZEND_HASH_MAP_FOREACH_PTR(CG(auto_globals), auto_global) {
if (auto_global->jit) {
auto_global->armed = 1;
} else if (auto_global->auto_global_callback) {
Expand Down Expand Up @@ -5768,7 +5768,7 @@ static void zend_compile_try(zend_ast *ast) /* {{{ */
/* label: try { } must not be equal to try { label: } */
if (CG(context).labels) {
zend_label *label;
ZEND_HASH_REVERSE_FOREACH_PTR(CG(context).labels, label) {
ZEND_HASH_MAP_REVERSE_FOREACH_PTR(CG(context).labels, label) {
if (label->opline_num == get_next_op_number()) {
zend_emit_op(NULL, ZEND_NOP, NULL, NULL);
}
Expand Down Expand Up @@ -6440,7 +6440,7 @@ static void zend_compile_attributes(HashTable **attributes, zend_ast *ast, uint3
}

/* Validate attributes in a secondary loop (needed to detect repeated attributes). */
ZEND_HASH_FOREACH_PTR(*attributes, attr) {
ZEND_HASH_PACKED_FOREACH_PTR(*attributes, attr) {
if (attr->offset != offset || NULL == (config = zend_internal_attribute_get(attr->lcname))) {
continue;
}
Expand Down Expand Up @@ -6881,7 +6881,7 @@ static void compile_implicit_lexical_binds(
op_array->static_variables = zend_new_array(8);
}

ZEND_HASH_FOREACH_STR_KEY(&info->uses, var_name)
ZEND_HASH_MAP_FOREACH_STR_KEY(&info->uses, var_name)
zval *value = zend_hash_add(
op_array->static_variables, var_name, &EG(uninitialized_zval));
uint32_t offset = (uint32_t)((char*)value - (char*)op_array->static_variables->arData);
Expand Down Expand Up @@ -6930,7 +6930,7 @@ static void zend_compile_closure_uses(zend_ast *ast) /* {{{ */
static void zend_compile_implicit_closure_uses(closure_info *info)
{
zend_string *var_name;
ZEND_HASH_FOREACH_STR_KEY(&info->uses, var_name)
ZEND_HASH_MAP_FOREACH_STR_KEY(&info->uses, var_name)
zval zv;
ZVAL_NULL(&zv);
zend_compile_static_var_common(var_name, &zv, ZEND_BIND_IMPLICIT);
Expand Down
4 changes: 2 additions & 2 deletions Zend/zend_enum.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,7 @@ static void zend_verify_enum_properties(zend_class_entry *ce)
{
zend_property_info *property_info;

ZEND_HASH_FOREACH_PTR(&ce->properties_info, property_info) {
ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, property_info) {
if (zend_string_equals_literal(property_info->name, "name")) {
continue;
}
Expand Down Expand Up @@ -192,7 +192,7 @@ static ZEND_NAMED_FUNCTION(zend_enum_cases_func)

array_init(return_value);

ZEND_HASH_FOREACH_PTR(CE_CONSTANTS_TABLE(ce), c) {
ZEND_HASH_MAP_FOREACH_PTR(CE_CONSTANTS_TABLE(ce), c) {
if (!(ZEND_CLASS_CONST_FLAGS(c) & ZEND_CLASS_CONST_IS_CASE)) {
continue;
}
Expand Down
Loading