diff options
66 files changed, 1163 insertions, 1073 deletions
diff --git a/Zend/zend.c b/Zend/zend.c index cef24c085b..a722531283 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -309,34 +309,23 @@ again: } /* }}} */ -ZEND_API int zend_print_zval(zval *expr, int indent) /* {{{ */ +ZEND_API int zend_print_zval(zval *expr, int indent TSRMLS_DC) /* {{{ */ { - return zend_print_zval_ex(zend_write, expr, indent); + return zend_print_zval_ex(zend_write, expr, indent TSRMLS_CC); } /* }}} */ -ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */ +ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC) /* {{{ */ { - zval expr_copy; - int use_copy; - int ret; + zend_string *str = zval_get_string(expr); + int len = str->len; - zend_make_printable_zval(expr, &expr_copy, &use_copy); - if (use_copy) { - expr = &expr_copy; + if (len != 0) { + write_func(str->val, len); } - if (Z_STRLEN_P(expr) == 0) { /* optimize away empty strings */ - if (use_copy) { - zval_dtor(expr); - } - return 0; - } - write_func(Z_STRVAL_P(expr), Z_STRLEN_P(expr)); - ret = Z_STRLEN_P(expr); - if (use_copy) { - zval_dtor(expr); - } - return ret; + + STR_RELEASE(str); + return len; } /* }}} */ @@ -345,14 +334,14 @@ ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */ switch (Z_TYPE_P(expr)) { case IS_ARRAY: ZEND_PUTS("Array ("); - if (++Z_ARRVAL_P(expr)->nApplyCount>1) { + if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) { ZEND_PUTS(" *RECURSION*"); - Z_ARRVAL_P(expr)->nApplyCount--; + Z_ARRVAL_P(expr)->u.v.nApplyCount--; return; } print_flat_hash(Z_ARRVAL_P(expr) TSRMLS_CC); ZEND_PUTS(")"); - Z_ARRVAL_P(expr)->nApplyCount--; + Z_ARRVAL_P(expr)->u.v.nApplyCount--; break; case IS_OBJECT: { @@ -374,19 +363,19 @@ ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */ properties = Z_OBJPROP_P(expr); } if (properties) { - if (++properties->nApplyCount>1) { + if (++properties->u.v.nApplyCount>1) { ZEND_PUTS(" *RECURSION*"); - properties->nApplyCount--; + properties->u.v.nApplyCount--; return; } print_flat_hash(properties TSRMLS_CC); - properties->nApplyCount--; + properties->u.v.nApplyCount--; } ZEND_PUTS(")"); break; } default: - zend_print_variable(expr); + zend_print_variable(expr TSRMLS_CC); break; } } @@ -404,13 +393,13 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int switch (Z_TYPE_P(expr)) { case IS_ARRAY: ZEND_PUTS_EX("Array\n"); - if (++Z_ARRVAL_P(expr)->nApplyCount>1) { + if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) { ZEND_PUTS_EX(" *RECURSION*"); - Z_ARRVAL_P(expr)->nApplyCount--; + Z_ARRVAL_P(expr)->u.v.nApplyCount--; return; } print_hash(write_func, Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC); - Z_ARRVAL_P(expr)->nApplyCount--; + Z_ARRVAL_P(expr)->u.v.nApplyCount--; break; case IS_OBJECT: { @@ -433,13 +422,13 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int if ((properties = Z_OBJDEBUG_P(expr, is_temp)) == NULL) { break; } - if (++properties->nApplyCount>1) { + if (++properties->u.v.nApplyCount>1) { ZEND_PUTS_EX(" *RECURSION*"); - properties->nApplyCount--; + properties->u.v.nApplyCount--; return; } print_hash(write_func, properties, indent, 1 TSRMLS_CC); - properties->nApplyCount--; + properties->u.v.nApplyCount--; if (is_temp) { zend_hash_destroy(properties); efree(properties); @@ -447,7 +436,7 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int break; } default: - zend_print_zval_ex(write_func, expr, indent); + zend_print_zval_ex(write_func, expr, indent TSRMLS_CC); break; } } @@ -516,11 +505,11 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS compiler_globals->compiled_filename = NULL; compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable)); - zend_hash_init_ex(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0); + zend_hash_init_ex(compiler_globals->function_table, 1024, NULL, ZEND_FUNCTION_DTOR, 1, 0); zend_hash_copy(compiler_globals->function_table, global_function_table, function_copy_ctor); compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable)); - zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0); + zend_hash_init_ex(compiler_globals->class_table, 64, NULL, ZEND_CLASS_DTOR, 1, 0); zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref); zend_set_default_compile_time_values(TSRMLS_C); @@ -723,12 +712,12 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS GLOBAL_AUTO_GLOBALS_TABLE = (HashTable *) malloc(sizeof(HashTable)); GLOBAL_CONSTANTS_TABLE = (HashTable *) malloc(sizeof(HashTable)); - zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0); - zend_hash_init_ex(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1, 0); + zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 1024, NULL, ZEND_FUNCTION_DTOR, 1, 0); + zend_hash_init_ex(GLOBAL_CLASS_TABLE, 64, NULL, ZEND_CLASS_DTOR, 1, 0); zend_hash_init_ex(GLOBAL_AUTO_GLOBALS_TABLE, 8, NULL, auto_global_dtor, 1, 0); - zend_hash_init_ex(GLOBAL_CONSTANTS_TABLE, 20, NULL, ZEND_CONSTANT_DTOR, 1, 0); + zend_hash_init_ex(GLOBAL_CONSTANTS_TABLE, 128, NULL, ZEND_CONSTANT_DTOR, 1, 0); - zend_hash_init_ex(&module_registry, 50, NULL, module_destructor_zval, 1, 0); + zend_hash_init_ex(&module_registry, 32, NULL, module_destructor_zval, 1, 0); zend_init_rsrc_list_dtors(); #ifdef ZTS diff --git a/Zend/zend.h b/Zend/zend.h index c81c223a7f..3aae759dde 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -555,8 +555,8 @@ END_EXTERN_C() BEGIN_EXTERN_C() ZEND_API char *get_zend_version(void); ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy); -ZEND_API int zend_print_zval(zval *expr, int indent); -ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent); +ZEND_API int zend_print_zval(zval *expr, int indent TSRMLS_DC); +ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC); ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC); ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC); ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC); diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 7d79d99bee..6cf6cb2157 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -2836,6 +2836,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca zend_class_entry *last_scope; HashTable *ftable; int call_via_handler = 0; + ALLOCA_FLAG(use_heap) if (error) { *error = NULL; @@ -2845,22 +2846,27 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca fcc->function_handler = NULL; if (!ce_org) { + char *lmname; + int lmname_len; + /* Skip leading \ */ if (Z_STRVAL_P(callable)[0] == '\\') { - lmname = STR_ALLOC(Z_STRLEN_P(callable) - 1, 0); - zend_str_tolower_copy(lmname->val, Z_STRVAL_P(callable) + 1, Z_STRLEN_P(callable) - 1); + lmname = do_alloca(Z_STRLEN_P(callable) - 1, use_heap); + lmname_len = Z_STRLEN_P(callable) - 1; + zend_str_tolower_copy(lmname, Z_STRVAL_P(callable) + 1, lmname_len); } else { - lmname = STR_ALLOC(Z_STRLEN_P(callable), 0); - zend_str_tolower_copy(lmname->val, Z_STRVAL_P(callable), Z_STRLEN_P(callable)); + lmname = do_alloca(Z_STRLEN_P(callable), use_heap); + lmname_len = Z_STRLEN_P(callable); + zend_str_tolower_copy(lmname, Z_STRVAL_P(callable), lmname_len); } /* Check if function with given name exists. * This may be a compound name that includes namespace name */ - fcc->function_handler = zend_hash_find_ptr(EG(function_table), lmname); + fcc->function_handler = zend_hash_str_find_ptr(EG(function_table), lmname, lmname_len); if (fcc->function_handler != NULL) { - STR_FREE(lmname); + free_alloca(lmname, use_heap); return 1; } - STR_FREE(lmname); + free_alloca(lmname, use_heap); } /* Split name into class/namespace and method/function names */ @@ -3283,12 +3289,7 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint default: if (callable_name) { - zval expr_copy; - int use_copy; - - zend_make_printable_zval(callable, &expr_copy, &use_copy); - *callable_name = STR_COPY(Z_STR(expr_copy)); - zval_dtor(&expr_copy); + *callable_name = zval_get_string(callable); } if (error) zend_spprintf(error, 0, "no array or string given"); return 0; diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 182c34f9ab..4664532b8f 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -662,14 +662,13 @@ ZEND_FUNCTION(error_reporting) Define a new constant */ ZEND_FUNCTION(define) { - char *name; - int name_len; + zend_string *name; zval *val, val_free; zend_bool non_cs = 0; int case_sensitive = CONST_CS; zend_constant c; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|b", &name, &val, &non_cs) == FAILURE) { return; } @@ -678,7 +677,7 @@ ZEND_FUNCTION(define) } /* class constant, check if there is name and make sure class is valid & exists */ - if (zend_memnstr(name, "::", sizeof("::") - 1, name + name_len)) { + if (zend_memnstr(name->val, "::", sizeof("::") - 1, name->val + name->len)) { zend_error(E_WARNING, "Class constants cannot be defined or redefined"); RETURN_FALSE; } @@ -718,10 +717,7 @@ repeat: ZVAL_DUP(&c.value, val); zval_ptr_dtor(&val_free); c.flags = case_sensitive; /* non persistent */ - c.name = STR_INIT(name, name_len, 1); - if(c.name == NULL) { - RETURN_FALSE; - } + c.name = STR_COPY(name); c.module_number = PHP_USER_CONSTANT; if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) { RETURN_TRUE; diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index 7b587a9223..9d48dab9f2 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -90,7 +90,7 @@ ZEND_METHOD(Closure, bind) } else if (Z_TYPE_P(scope_arg) == IS_NULL) { ce = NULL; } else { - zend_string *class_name = zval_get_string(scope_arg TSRMLS_CC); + zend_string *class_name = zval_get_string(scope_arg); if ((class_name->len == sizeof("static") - 1) && (memcmp("static", class_name->val, sizeof("static") - 1) == 0)) { ce = closure->func.common.scope; @@ -292,9 +292,9 @@ static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_ if (closure->debug_info == NULL) { ALLOC_HASHTABLE(closure->debug_info); - zend_hash_init(closure->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(closure->debug_info, 8, NULL, ZVAL_PTR_DTOR, 0); } - if (closure->debug_info->nApplyCount == 0) { + if (closure->debug_info->u.v.nApplyCount == 0) { if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) { HashTable *static_variables = closure->func.op_array.static_variables; array_init(&val); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 14d937bb55..a6032cd109 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -213,7 +213,7 @@ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */ CG(current_import) = NULL; CG(current_import_function) = NULL; CG(current_import_const) = NULL; - zend_hash_init(&CG(const_filenames), 0, NULL, NULL, 0); + zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0); init_compiler_declarables(TSRMLS_C); zend_stack_init(&CG(context_stack)); @@ -235,7 +235,7 @@ void init_compiler(TSRMLS_D) /* {{{ */ memset(&CG(context), 0, sizeof(CG(context))); zend_init_compiler_data_structures(TSRMLS_C); zend_init_rsrc_list(TSRMLS_C); - zend_hash_init(&CG(filenames_table), 5, NULL, free_string_zval, 0); + zend_hash_init(&CG(filenames_table), 8, NULL, free_string_zval, 0); zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0); CG(unclean_shutdown) = 0; } @@ -2364,7 +2364,7 @@ void zend_do_label(znode *label TSRMLS_DC) /* {{{ */ if (!CG(context).labels) { ALLOC_HASHTABLE(CG(context).labels); - zend_hash_init(CG(context).labels, 4, NULL, ptr_dtor, 0); + zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0); } dest.brk_cont = CG(context).current_brk_cont; @@ -3478,8 +3478,7 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ } } if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { - zval zv, zv_copy; - int use_copy; + zval zv; ZVAL_DUP(&zv, precv->op2.zv); zval_update_constant_ex(&zv, (void*)1, fptr->common.scope TSRMLS_CC); @@ -3509,13 +3508,11 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ memcpy(offset, "Array", 5); offset += 5; } else { - zend_make_printable_zval(&zv, &zv_copy, &use_copy); - REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN(zv_copy)); - memcpy(offset, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy)); - offset += Z_STRLEN(zv_copy); - if (use_copy) { - zval_dtor(&zv_copy); - } + zend_string *str = zval_get_string(&zv); + REALLOC_BUF_IF_EXCEED(buf, offset, length, str->len); + memcpy(offset, str->val, str->len); + offset += str->len; + STR_RELEASE(str); } zval_ptr_dtor(&zv); } @@ -4066,7 +4063,7 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s } } else { ALLOC_HASHTABLE(*overriden); - zend_hash_init_ex(*overriden, 2, NULL, ptr_dtor, 0, 0); + zend_hash_init_ex(*overriden, 8, NULL, ptr_dtor, 0, 0); } fn = zend_hash_update_mem(*overriden, key, fn, sizeof(zend_function)); return; @@ -4371,7 +4368,7 @@ static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{ HashTable exclude_table; /* TODO: revisit this start size, may be its not optimal */ - zend_hash_init_ex(&exclude_table, 2, NULL, NULL, 0, 0); + zend_hash_init_ex(&exclude_table, 8, NULL, NULL, 0, 0); zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]); @@ -6115,7 +6112,7 @@ void zend_do_fetch_static_variable(znode *varname, const znode *static_assignmen CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; } ALLOC_HASHTABLE(CG(active_op_array)->static_variables); - zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0); } zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp); @@ -6933,9 +6930,9 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify ce->default_properties_table = NULL; ce->default_static_members_table = NULL; - zend_hash_init_ex(&ce->properties_info, 0, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0); - zend_hash_init_ex(&ce->constants_table, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0); - zend_hash_init_ex(&ce->function_table, 0, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); + zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0); + zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0); + zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0); if (ce->type == ZEND_INTERNAL_CLASS) { #ifdef ZTS @@ -7136,7 +7133,7 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{ if (!CG(current_import)) { CG(current_import) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0); } ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0); @@ -7299,7 +7296,7 @@ void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_ { if (!CG(current_import_function)) { CG(current_import_function) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_function), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0); } zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC); @@ -7310,7 +7307,7 @@ void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) { if (!CG(current_import_const)) { CG(current_import_const) = emalloc(sizeof(HashTable)); - zend_hash_init(CG(current_import_const), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0); } zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC); diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 6681455992..efcbe2b5d3 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -664,12 +664,10 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC); ZEND_API void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC); ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC); ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC); -ZEND_API int zend_cleanup_class_data(zval *zv TSRMLS_DC); -ZEND_API int zend_cleanup_user_class_data(zval *zv TSRMLS_DC); +ZEND_API void zend_cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC); ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC); ZEND_API void zend_cleanup_internal_classes(TSRMLS_D); -ZEND_API int zend_cleanup_function_data(zval *zv TSRMLS_DC); -ZEND_API int zend_cleanup_function_data_full(zval *zv TSRMLS_DC); +ZEND_API void zend_cleanup_op_array_data(zend_op_array *op_array); ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC); ZEND_API void zend_function_dtor(zval *zv); diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c index f3c58065ee..30ae65d267 100644 --- a/Zend/zend_constants.c +++ b/Zend/zend_constants.c @@ -102,9 +102,7 @@ int zend_startup_constants(TSRMLS_D) { EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable)); - if (zend_hash_init(EG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1)==FAILURE) { - return FAILURE; - } + zend_hash_init(EG(zend_constants), 128, NULL, ZEND_CONSTANT_DTOR, 1); return SUCCESS; } diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index b6a4031221..839fc491ef 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -990,7 +990,7 @@ static void zend_extension_fcall_end_handler(const zend_extension *extension, ze } -static inline HashTable *zend_get_target_symbol_table(int fetch_type TSRMLS_DC) +static zend_always_inline HashTable *zend_get_target_symbol_table(int fetch_type TSRMLS_DC) { HashTable *ht; diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 8d5b55c84d..0091fea00d 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -160,13 +160,13 @@ void init_executor(TSRMLS_D) /* {{{ */ ZVAL_LONG(&tmp, 0); zend_vm_stack_push(&tmp TSRMLS_CC); - zend_hash_init(&EG(symbol_table).ht, 50, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(&EG(symbol_table).ht, 64, NULL, ZVAL_PTR_DTOR, 0); EG(active_symbol_table) = &EG(symbol_table); zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator TSRMLS_CC); EG(opline_ptr) = NULL; - zend_hash_init(&EG(included_files), 5, NULL, NULL, 0); + zend_hash_init(&EG(included_files), 8, NULL, NULL, 0); EG(ticks_count) = 0; @@ -245,6 +245,9 @@ void shutdown_destructors(TSRMLS_D) /* {{{ */ void shutdown_executor(TSRMLS_D) /* {{{ */ { + zend_function *func; + zend_class_entry *ce; + zend_try { /* Removed because this can not be safely done, e.g. in this situation: @@ -303,11 +306,31 @@ void shutdown_executor(TSRMLS_D) /* {{{ */ * Note that only run-time accessed data need to be cleaned up, pre-defined data can * not contain objects and thus are not probelmatic */ if (EG(full_tables_cleanup)) { - zend_hash_apply(EG(function_table), zend_cleanup_function_data_full TSRMLS_CC); - zend_hash_apply(EG(class_table), zend_cleanup_class_data TSRMLS_CC); + ZEND_HASH_FOREACH_PTR(EG(function_table), func) { + if (func->type == ZEND_USER_FUNCTION) { + zend_cleanup_op_array_data((zend_op_array *) func); + } + } ZEND_HASH_FOREACH_END(); + ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) { + if (ce->type == ZEND_USER_CLASS) { + zend_cleanup_user_class_data(ce TSRMLS_CC); + } else { + zend_cleanup_internal_class_data(ce TSRMLS_CC); + } + } ZEND_HASH_FOREACH_END(); } else { - zend_hash_reverse_apply(EG(function_table), zend_cleanup_function_data TSRMLS_CC); - zend_hash_reverse_apply(EG(class_table), zend_cleanup_user_class_data TSRMLS_CC); + ZEND_HASH_REVERSE_FOREACH_PTR(EG(function_table), func) { + if (func->type != ZEND_USER_FUNCTION) { + break; + } + zend_cleanup_op_array_data((zend_op_array *) func); + } ZEND_HASH_FOREACH_END(); + ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) { + if (ce->type != ZEND_USER_CLASS) { + break; + } + zend_cleanup_user_class_data(ce TSRMLS_CC); + } ZEND_HASH_FOREACH_END(); zend_cleanup_internal_classes(TSRMLS_C); } } zend_end_try(); @@ -1049,6 +1072,19 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k return NULL; } + if (!EG(autoload_func)) { + zend_function *func = zend_hash_str_find_ptr(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1); + if (func) { + EG(autoload_func) = func; + } else { + if (!key) { + STR_FREE(lc_name); + } + return NULL; + } + + } + /* Verify class name before passing it to __autoload() */ if (strspn(name->val, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\") != name->len) { if (!key) { @@ -1059,7 +1095,7 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k if (EG(in_autoload) == NULL) { ALLOC_HASHTABLE(EG(in_autoload)); - zend_hash_init(EG(in_autoload), 0, NULL, NULL, 0); + zend_hash_init(EG(in_autoload), 8, NULL, NULL, 0); } if (zend_hash_add_empty_element(EG(in_autoload), lc_name) == NULL) { @@ -1079,7 +1115,7 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k fcall_info.size = sizeof(fcall_info); fcall_info.function_table = EG(function_table); - ZVAL_STRINGL(&fcall_info.function_name, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1); + ZVAL_STR(&fcall_info.function_name, STR_COPY(EG(autoload_func)->common.function_name)); fcall_info.symbol_table = NULL; fcall_info.retval = &local_retval; fcall_info.param_count = 1; @@ -1087,7 +1123,7 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k fcall_info.object = NULL; fcall_info.no_separation = 1; - fcall_cache.initialized = EG(autoload_func) ? 1 : 0; + fcall_cache.initialized = 1; fcall_cache.function_handler = EG(autoload_func); fcall_cache.calling_scope = NULL; fcall_cache.called_scope = NULL; @@ -1097,8 +1133,6 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *k retval = zend_call_function(&fcall_info, &fcall_cache TSRMLS_CC); zend_exception_restore(TSRMLS_C); - EG(autoload_func) = fcall_cache.function_handler; - zval_ptr_dtor(&args[0]); zval_dtor(&fcall_info.function_name); diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 5e3f823c83..38e027d608 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -33,10 +33,10 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int line) { - if ((ht->flags & HASH_MASK_CONSISTENCY) == HT_OK) { + if ((ht->u.flags & HASH_MASK_CONSISTENCY) == HT_OK) { return; } - switch ((ht->flags & HASH_MASK_CONSISTENCY)) { + switch ((ht->u.flags & HASH_MASK_CONSISTENCY)) { case HT_IS_DESTROYING: zend_output_debug_string(1, "%s(%d) : ht=%p is being destroyed", file, line, ht); break; @@ -54,7 +54,7 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int lin } #define IS_CONSISTENT(a) _zend_is_inconsistent(a, __FILE__, __LINE__); #define SET_INCONSISTENT(n) do { \ - (ht)->flags |= n; \ + (ht)->u.flags |= n; \ } while (0) #else #define IS_CONSISTENT(a) @@ -62,15 +62,16 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int lin #endif #define HASH_PROTECT_RECURSION(ht) \ - if ((ht)->flags & HASH_FLAG_APPLY_PROTECTION) { \ - if ((ht)->nApplyCount++ >= 3) { \ - zend_error(E_ERROR, "Nesting level too deep - recursive dependency?"); \ + if ((ht)->u.flags & HASH_FLAG_APPLY_PROTECTION) { \ + if ((ht)->u.flags >= (3 << 8)) { \ + zend_error_noreturn(E_ERROR, "Nesting level too deep - recursive dependency?");\ } \ + (ht)->u.flags += (1 << 8); \ } #define HASH_UNPROTECT_RECURSION(ht) \ - if ((ht)->flags & HASH_FLAG_APPLY_PROTECTION) { \ - (ht)->nApplyCount--; \ + if ((ht)->u.flags & HASH_FLAG_APPLY_PROTECTION) { \ + (ht)->u.flags -= (1 << 8); \ } #define ZEND_HASH_IF_FULL_DO_RESIZE(ht) \ @@ -83,10 +84,10 @@ static void zend_hash_do_resize(HashTable *ht); #define CHECK_INIT(ht, packed) do { \ if (UNEXPECTED((ht)->nTableMask == 0)) { \ if (packed) { \ - (ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket), 0, (ht)->flags & HASH_FLAG_PERSISTENT); \ - (ht)->flags |= HASH_FLAG_PACKED; \ + (ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket), 0, (ht)->u.flags & HASH_FLAG_PERSISTENT); \ + (ht)->u.flags |= HASH_FLAG_PACKED; \ } else { \ - (ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, (ht)->flags & HASH_FLAG_PERSISTENT); \ + (ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, (ht)->u.flags & HASH_FLAG_PERSISTENT); \ (ht)->arHash = (zend_uint*)((ht)->arData + (ht)->nTableSize); \ memset((ht)->arHash, INVALID_IDX, (ht)->nTableSize * sizeof(zend_uint)); \ } \ @@ -96,11 +97,10 @@ static void zend_hash_do_resize(HashTable *ht); static const zend_uint uninitialized_bucket = {INVALID_IDX}; -ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC) +ZEND_API void _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC) { uint i = 3; - ht->flags = 0; SET_INCONSISTENT(HT_OK); if (nSize >= 0x80000000) { @@ -114,25 +114,24 @@ ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, } ht->nTableMask = 0; /* 0 means that ht->arBuckets is uninitialized */ - ht->pDestructor = pDestructor; - ht->arData = NULL; - ht->arHash = (zend_uint*)&uninitialized_bucket; ht->nNumUsed = 0; ht->nNumOfElements = 0; ht->nNextFreeElement = 0; + ht->arData = NULL; + ht->arHash = (zend_uint*)&uninitialized_bucket; + ht->pDestructor = pDestructor; ht->nInternalPointer = INVALID_IDX; - ht->flags |= HASH_FLAG_APPLY_PROTECTION; if (persistent) { - ht->flags |= HASH_FLAG_PERSISTENT; + ht->u.flags = HASH_FLAG_PERSISTENT | HASH_FLAG_APPLY_PROTECTION; + } else { + ht->u.flags = HASH_FLAG_APPLY_PROTECTION; } - ht->nApplyCount = 0; - return SUCCESS; } static void zend_hash_packed_grow(HashTable *ht) { HANDLE_BLOCK_INTERRUPTIONS(); - ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket), 0, ht->flags & HASH_FLAG_PERSISTENT); + ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket), 0, ht->u.flags & HASH_FLAG_PERSISTENT); ht->nTableSize = (ht->nTableSize << 1); ht->nTableMask = ht->nTableSize - 1; HANDLE_UNBLOCK_INTERRUPTIONS(); @@ -148,8 +147,8 @@ ZEND_API void zend_hash_real_init(HashTable *ht, int packed) ZEND_API void zend_hash_packed_to_hash(HashTable *ht) { HANDLE_BLOCK_INTERRUPTIONS(); - ht->flags &= ~HASH_FLAG_PACKED; - ht->arData = (Bucket *) safe_perealloc(ht->arData, ht->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, ht->flags & HASH_FLAG_PERSISTENT); + ht->u.flags &= ~HASH_FLAG_PACKED; + ht->arData = (Bucket *) safe_perealloc(ht->arData, ht->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, ht->u.flags & HASH_FLAG_PERSISTENT); ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize); zend_hash_rehash(ht); HANDLE_UNBLOCK_INTERRUPTIONS(); @@ -158,29 +157,27 @@ ZEND_API void zend_hash_packed_to_hash(HashTable *ht) ZEND_API void zend_hash_to_packed(HashTable *ht) { HANDLE_BLOCK_INTERRUPTIONS(); - ht->flags |= HASH_FLAG_PACKED; + ht->u.flags |= HASH_FLAG_PACKED; ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket)); ht->arHash = (zend_uint*)&uninitialized_bucket; HANDLE_UNBLOCK_INTERRUPTIONS(); } -ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC) +ZEND_API void _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC) { - int retval = _zend_hash_init(ht, nSize, pDestructor, persistent ZEND_FILE_LINE_CC); - + _zend_hash_init(ht, nSize, pDestructor, persistent ZEND_FILE_LINE_CC); if (!bApplyProtection) { - ht->flags &= ~HASH_FLAG_APPLY_PROTECTION; + ht->u.flags &= ~HASH_FLAG_APPLY_PROTECTION; } - return retval; } ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProtection) { if (bApplyProtection) { - ht->flags |= HASH_FLAG_APPLY_PROTECTION; + ht->u.flags |= HASH_FLAG_APPLY_PROTECTION; } else { - ht->flags &= ~HASH_FLAG_APPLY_PROTECTION; + ht->u.flags &= ~HASH_FLAG_APPLY_PROTECTION; } } @@ -260,7 +257,7 @@ ZEND_API zval *_zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *p IS_CONSISTENT(ht); CHECK_INIT(ht, 0); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { zend_hash_packed_to_hash(ht); } @@ -310,7 +307,7 @@ ZEND_API zval *_zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *p ZEND_API zval *_zend_hash_str_add_or_update(HashTable *ht, const char *str, int len, zval *pData, int flag ZEND_FILE_LINE_DC) { - zend_string *key = STR_INIT(str, len, ht->flags & HASH_FLAG_PERSISTENT); + zend_string *key = STR_INIT(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); zval *ret = _zend_hash_add_or_update(ht, key, pData, flag ZEND_FILE_LINE_CC); STR_RELEASE(key); return ret; @@ -350,7 +347,7 @@ ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, zv } CHECK_INIT(ht, h >= 0 && h < ht->nTableSize); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (EXPECTED(h >= 0)) { if (h < ht->nNumUsed) { p = ht->arData + h; @@ -465,7 +462,7 @@ static void zend_hash_do_resize(HashTable *ht) HANDLE_UNBLOCK_INTERRUPTIONS(); } else if ((ht->nTableSize << 1) > 0) { /* Let's double the table size */ HANDLE_BLOCK_INTERRUPTIONS(); - ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket) + sizeof(zend_uint), 0, ht->flags & HASH_FLAG_PERSISTENT); + ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket) + sizeof(zend_uint), 0, ht->u.flags & HASH_FLAG_PERSISTENT); ht->arHash = (zend_uint*)(ht->arData + (ht->nTableSize << 1)); ht->nTableSize = (ht->nTableSize << 1); ht->nTableMask = ht->nTableSize - 1; @@ -506,7 +503,7 @@ ZEND_API int zend_hash_rehash(HashTable *ht) static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint idx, Bucket *p, Bucket *prev) { - if (!(ht->flags & HASH_FLAG_PACKED)) { + if (!(ht->u.flags & HASH_FLAG_PACKED)) { if (prev) { Z_NEXT(prev->val) = Z_NEXT(p->val); } else { @@ -549,7 +546,7 @@ static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint idx, Bucket uint nIndex; Bucket *prev = NULL; - if (!(ht->flags & HASH_FLAG_PACKED)) { + if (!(ht->u.flags & HASH_FLAG_PACKED)) { nIndex = p->h & ht->nTableMask; idx = ht->arHash[nIndex]; if (p != ht->arData + idx) { @@ -578,7 +575,7 @@ ZEND_API int zend_hash_del(HashTable *ht, zend_string *key) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return FAILURE; } @@ -617,7 +614,7 @@ ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return FAILURE; } @@ -749,7 +746,7 @@ ZEND_API int zend_hash_index_del(HashTable *ht, ulong h) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (h >=0 && h < ht->nNumUsed) { p = ht->arData + h; if (Z_TYPE(p->val) != IS_UNDEF) { @@ -798,7 +795,7 @@ ZEND_API void zend_hash_destroy(HashTable *ht) } } if (ht->nTableMask) { - pefree(ht->arData, ht->flags & HASH_FLAG_PERSISTENT); + pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT); } SET_INCONSISTENT(HT_DESTROYED); @@ -827,7 +824,7 @@ ZEND_API void zend_hash_clean(HashTable *ht) ht->nNextFreeElement = 0; ht->nInternalPointer = INVALID_IDX; if (ht->nTableMask) { - if (!(ht->flags & HASH_FLAG_PACKED)) { + if (!(ht->u.flags & HASH_FLAG_PACKED)) { memset(ht->arHash, INVALID_IDX, ht->nTableSize * sizeof(zend_uint)); } } @@ -863,7 +860,7 @@ ZEND_API void zend_hash_graceful_destroy(HashTable *ht) zend_hash_apply_deleter(ht, idx, p); } if (ht->nTableMask) { - pefree(ht->arData, ht->flags & HASH_FLAG_PERSISTENT); + pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT); } SET_INCONSISTENT(HT_DESTROYED); @@ -885,7 +882,7 @@ ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht) } if (ht->nTableMask) { - pefree(ht->arData, ht->flags & HASH_FLAG_PERSISTENT); + pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT); } SET_INCONSISTENT(HT_DESTROYED); @@ -1146,7 +1143,7 @@ ZEND_API zval *zend_hash_find(const HashTable *ht, zend_string *key) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return NULL; } @@ -1161,7 +1158,7 @@ ZEND_API zval *zend_hash_str_find(const HashTable *ht, const char *str, int len) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return NULL; } @@ -1176,7 +1173,7 @@ ZEND_API int zend_hash_exists(const HashTable *ht, zend_string *key) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return 0; } @@ -1191,7 +1188,7 @@ ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { return 0; } @@ -1206,7 +1203,7 @@ ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (h >= 0 && h < ht->nNumUsed) { p = ht->arData + h; if (Z_TYPE(p->val) != IS_UNDEF) { @@ -1227,7 +1224,7 @@ ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h) IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (h >= 0 && h < ht->nNumUsed) { if (Z_TYPE(ht->arData[h].val) != IS_UNDEF) { return 1; @@ -1280,7 +1277,7 @@ ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr) return 0; } else if (ht->nInternalPointer != ptr->pos) { IS_CONSISTENT(ht); - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (Z_TYPE(ht->arData[ptr->h].val) != IS_UNDEF) { ht->nInternalPointer = ptr->h; return 1; @@ -1606,13 +1603,13 @@ ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, if (renumber) { ht->nNextFreeElement = i; } - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (!renumber) { zend_hash_packed_to_hash(ht); } } else { if (renumber) { - ht->flags |= HASH_FLAG_PACKED; + ht->u.flags |= HASH_FLAG_PACKED; ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket)); ht->arHash = (zend_uint*)&uninitialized_bucket; } else { diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h index c770539dd1..cc1dcca0e7 100644 --- a/Zend/zend_hash.h +++ b/Zend/zend_hash.h @@ -60,8 +60,8 @@ typedef uint HashPosition; BEGIN_EXTERN_C() /* startup/shutdown */ -ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC); -ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC); +ZEND_API void _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC); +ZEND_API void _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC); ZEND_API void zend_hash_destroy(HashTable *ht); ZEND_API void zend_hash_clean(HashTable *ht); #define zend_hash_init(ht, nSize, pHashFunction, pDestructor, persistent) _zend_hash_init((ht), (nSize), (pDestructor), (persistent) ZEND_FILE_LINE_CC) @@ -207,7 +207,7 @@ void zend_hash_display(const HashTable *ht); END_EXTERN_C() #define ZEND_INIT_SYMTABLE(ht) \ - ZEND_INIT_SYMTABLE_EX(ht, 2, 0) + ZEND_INIT_SYMTABLE_EX(ht, 8, 0) #define ZEND_INIT_SYMTABLE_EX(ht, n, persistent) \ zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent) @@ -418,12 +418,12 @@ static inline void *zend_hash_add_mem(HashTable *ht, zend_string *key, void *pDa { void *p, *r; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); if ((r = zend_hash_add_ptr(ht, key, p))) { return r; } - pefree(p, ht->flags & HASH_FLAG_PERSISTENT); + pefree(p, ht->u.flags & HASH_FLAG_PERSISTENT); return NULL; } @@ -431,12 +431,12 @@ static inline void *zend_hash_str_add_mem(HashTable *ht, const char *str, int le { void *p, *r; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); if ((r = zend_hash_str_add_ptr(ht, str, len, p))) { return r; } - pefree(p, ht->flags & HASH_FLAG_PERSISTENT); + pefree(p, ht->u.flags & HASH_FLAG_PERSISTENT); return NULL; } @@ -444,7 +444,7 @@ static inline void *zend_hash_update_mem(HashTable *ht, zend_string *key, void * { void *p; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); return zend_hash_update_ptr(ht, key, p); } @@ -453,7 +453,7 @@ static inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, int { void *p; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); return zend_hash_str_update_ptr(ht, str, len, p); } @@ -480,7 +480,7 @@ static inline void *zend_hash_index_update_mem(HashTable *ht, ulong h, void *pDa { void *p; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); return zend_hash_index_update_ptr(ht, h, p); } @@ -489,12 +489,12 @@ static inline void *zend_hash_next_index_insert_mem(HashTable *ht, void *pData, { void *p, *r; - p = pemalloc(size, ht->flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); memcpy(p, pData, size); if ((r = zend_hash_next_index_insert_ptr(ht, p))) { return r; } - pefree(p, ht->flags & HASH_FLAG_PERSISTENT); + pefree(p, ht->u.flags & HASH_FLAG_PERSISTENT); return NULL; } @@ -596,6 +596,10 @@ static inline void *zend_hash_get_current_data_ptr_ex(HashTable *ht, HashPositio ZEND_HASH_REVERSE_FOREACH(ht, 0); \ _val = _z; +#define ZEND_HASH_REVERSE_FOREACH_PTR(ht, _ptr) \ + ZEND_HASH_REVERSE_FOREACH(ht, 0); \ + _ptr = Z_PTR_P(_z); + #define ZEND_HASH_REVERSE_FOREACH_VAL_IND(ht, _val) \ ZEND_HASH_REVERSE_FOREACH(ht, 1); \ _val = _z; diff --git a/Zend/zend_ini.c b/Zend/zend_ini.c index 4ac379ca91..883a6bf84b 100644 --- a/Zend/zend_ini.c +++ b/Zend/zend_ini.c @@ -99,9 +99,7 @@ ZEND_API int zend_ini_startup(TSRMLS_D) /* {{{ */ EG(ini_directives) = registered_zend_ini_directives; EG(modified_ini_directives) = NULL; EG(error_reporting_ini_entry) = NULL; - if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, _free_ptr, 1, 0) == FAILURE) { - return FAILURE; - } + zend_hash_init_ex(registered_zend_ini_directives, 128, NULL, _free_ptr, 1, 0); return SUCCESS; } /* }}} */ @@ -140,9 +138,7 @@ ZEND_API int zend_copy_ini_directives(TSRMLS_D) /* {{{ */ EG(modified_ini_directives) = NULL; EG(error_reporting_ini_entry) = NULL; EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable)); - if (zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0) == FAILURE) { - return FAILURE; - } + zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0); zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, NULL); return SUCCESS; } diff --git a/Zend/zend_list.c b/Zend/zend_list.c index acd756bc99..fa1af76397 100644 --- a/Zend/zend_list.c +++ b/Zend/zend_list.c @@ -203,18 +203,15 @@ void plist_entry_destructor(zval *zv) int zend_init_rsrc_list(TSRMLS_D) { - if (zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0)==SUCCESS) { - EG(regular_list).nNextFreeElement = 1; /* we don't want resource id 0 */ - return SUCCESS; - } else { - return FAILURE; - } + zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0); + return SUCCESS; } int zend_init_rsrc_plist(TSRMLS_D) { - return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0); + zend_hash_init_ex(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1, 0); + return SUCCESS; } @@ -334,10 +331,9 @@ int zend_init_rsrc_list_dtors(void) { int retval; - retval = zend_hash_init(&list_destructors, 50, NULL, list_destructors_dtor, 1); + zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1); list_destructors.nNextFreeElement=1; /* we don't want resource type 0 */ - - return retval; + return SUCCESS; } diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 6350e7ed09..7a14ce939a 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -75,7 +75,7 @@ ZEND_API void rebuild_object_properties(zend_object *zobj) /* {{{ */ zend_class_entry *ce = zobj->ce; ALLOC_HASHTABLE(zobj->properties); - zend_hash_init(zobj->properties, 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(zobj->properties, 8, NULL, ZVAL_PTR_DTOR, 0); if (ce->default_properties_count) { ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) { if (/*prop_info->ce == ce &&*/ @@ -399,7 +399,7 @@ static long *zend_get_property_guard(zend_object *zobj, zend_property_info *prop } if (!zobj->guards) { ALLOC_HASHTABLE(zobj->guards); - zend_hash_init(zobj->guards, 0, NULL, NULL, 0); + zend_hash_init(zobj->guards, 8, NULL, NULL, 0); } else if ((guard = zend_hash_find(zobj->guards, property_info->name)) != NULL) { if (str) { STR_RELEASE(str); @@ -479,11 +479,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, zend_uint cac } else { retval = &EG(uninitialized_zval); } -//??? if (EXPECTED(retval != object)) { zval_ptr_dtor(&tmp_object); -//??? } else { -//??? Z_DELREF_P(object); -//??? } } else { if (Z_STRVAL_P(member)[0] == '\0') { if (Z_STRLEN_P(member) == 0) { diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index 2ffec7cd8e..1ef0e1d7e7 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -154,7 +154,7 @@ ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object *o if (!new_object->properties) { ALLOC_HASHTABLE(new_object->properties); - zend_hash_init(new_object->properties, 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(new_object->properties, 8, NULL, ZVAL_PTR_DTOR, 0); } ZEND_HASH_FOREACH_KEY_VAL(old_object->properties, num_key, key, prop) { diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 087960ca33..1987d819b8 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -132,42 +132,26 @@ ZEND_API void zend_function_dtor(zval *zv) pefree(function, function->type == ZEND_INTERNAL_FUNCTION); } -static void zend_cleanup_op_array_data(zend_op_array *op_array) +ZEND_API void zend_cleanup_op_array_data(zend_op_array *op_array) { if (op_array->static_variables) { zend_hash_clean(op_array->static_variables); } } -ZEND_API int zend_cleanup_function_data(zval *zv TSRMLS_DC) -{ - zend_function *function = Z_PTR_P(zv); - - if (function->type == ZEND_USER_FUNCTION) { - zend_cleanup_op_array_data((zend_op_array *) function); - return ZEND_HASH_APPLY_KEEP; - } else { - return ZEND_HASH_APPLY_STOP; - } -} - -ZEND_API int zend_cleanup_function_data_full(zval *zv TSRMLS_DC) -{ - zend_function *function = Z_PTR_P(zv); - - if (function->type == ZEND_USER_FUNCTION) { - zend_cleanup_op_array_data((zend_op_array *) function); - } - return 0; -} - -static inline void cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC) +ZEND_API void zend_cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC) { /* Clean all parts that can contain run-time data */ /* Note that only run-time accessed data need to be cleaned up, pre-defined data can not contain objects and thus are not probelmatic */ if (ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS) { - zend_hash_apply(&ce->function_table, zend_cleanup_function_data_full TSRMLS_CC); + zend_function *func; + + ZEND_HASH_FOREACH_PTR(&ce->function_table, func) { + if (func->type == ZEND_USER_FUNCTION) { + zend_cleanup_op_array_data((zend_op_array *) func); + } + } ZEND_HASH_FOREACH_END(); } if (ce->static_members_table) { int i; @@ -185,7 +169,7 @@ static inline void cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC) } } -static inline void cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC) +ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC) { if (CE_STATIC_MEMBERS(ce)) { int i; @@ -202,35 +186,6 @@ static inline void cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC) } } -ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC) -{ - cleanup_internal_class_data(ce TSRMLS_CC); -} - -ZEND_API int zend_cleanup_user_class_data(zval *zv TSRMLS_DC) -{ - zend_class_entry *ce = Z_PTR_P(zv); - - if (ce->type == ZEND_USER_CLASS) { - cleanup_user_class_data(ce TSRMLS_CC); - return ZEND_HASH_APPLY_KEEP; - } else { - return ZEND_HASH_APPLY_STOP; - } -} - -ZEND_API int zend_cleanup_class_data(zval *zv TSRMLS_DC) -{ - zend_class_entry *ce = Z_PTR_P(zv); - - if (ce->type == ZEND_USER_CLASS) { - cleanup_user_class_data(ce TSRMLS_CC); - } else { - cleanup_internal_class_data(ce TSRMLS_CC); - } - return 0; -} - void _destroy_zend_class_traits_info(zend_class_entry *ce) { if (ce->num_traits > 0 && ce->traits) { diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 47e2562da8..d943ae739a 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -683,7 +683,7 @@ static void convert_scalar_to_array(zval *op, int type TSRMLS_DC) /* {{{ */ switch (type) { case IS_ARRAY: ZVAL_NEW_ARR(op); - zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0); zend_hash_index_update(Z_ARRVAL_P(op), 0, &entry); break; case IS_OBJECT: @@ -707,7 +707,7 @@ ZEND_API void convert_to_array(zval *op) /* {{{ */ zval arr; ZVAL_NEW_ARR(&arr); - zend_hash_init(Z_ARRVAL(arr), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(Z_ARRVAL(arr), 8, NULL, ZVAL_PTR_DTOR, 0); if (Z_OBJCE_P(op) == zend_ce_closure) { convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC); if (Z_TYPE_P(op) == IS_ARRAY) { @@ -733,7 +733,7 @@ ZEND_API void convert_to_array(zval *op) /* {{{ */ break; case IS_NULL: ZVAL_NEW_ARR(op); - zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0); break; default: convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC); @@ -875,7 +875,7 @@ ZEND_API double zval_get_double(zval *op TSRMLS_DC) /* {{{ */ { zval tmp; ZVAL_DUP(&tmp, op); - convert_object_to_type(op, IS_DOUBLE, convert_to_double); + convert_object_to_type(&tmp, IS_DOUBLE, convert_to_double); if (Z_TYPE(tmp) == IS_DOUBLE) { return Z_DVAL(tmp); @@ -893,32 +893,33 @@ ZEND_API double zval_get_double(zval *op TSRMLS_DC) /* {{{ */ } /* }}} */ -ZEND_API zend_string *zval_get_string(zval *op TSRMLS_DC) /* {{{ */ +ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC) /* {{{ */ { +try_again: switch (Z_TYPE_P(op)) { case IS_NULL: return STR_EMPTY_ALLOC(); case IS_STRING: return STR_COPY(Z_STR_P(op)); case IS_BOOL: - if (Z_LVAL_P(op)) { + if (Z_BVAL_P(op)) { return STR_INIT("1", 1, 0); } else { return STR_EMPTY_ALLOC(); } case IS_RESOURCE: { - char *str; - int len = zend_spprintf(&str, 0, "Resource id #%ld", Z_RES_HANDLE_P(op)); - zend_string *retval = STR_INIT(str, len, 0); - efree(str); - return retval; + char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG]; + int len; + + len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op)); + return STR_INIT(buf, len, 0); } case IS_LONG: { - char *str; - int len = zend_spprintf(&str, 0, "%ld", Z_LVAL_P(op)); - zend_string *retval = STR_INIT(str, len, 0); - efree(str); - return retval; + char buf[MAX_LENGTH_OF_LONG + 1]; + int len; + + len = snprintf(buf, sizeof(buf), "%ld", Z_LVAL_P(op)); + return STR_INIT(buf, len, 0); } case IS_DOUBLE: { char *str; @@ -932,17 +933,28 @@ ZEND_API zend_string *zval_get_string(zval *op TSRMLS_DC) /* {{{ */ return STR_INIT("Array", sizeof("Array")-1, 0); case IS_OBJECT: { zval tmp; - ZVAL_DUP(&tmp, op); - convert_object_to_type(op, IS_STRING, convert_to_string); - - if (Z_TYPE(tmp) == IS_STRING) { - return Z_STR(tmp); - } else { - zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name->val); - zval_dtor(&tmp); - return STR_INIT("Object", sizeof("Object")-1, 0); + //???if (zend_std_cast_object_tostring(op, &tmp, IS_STRING TSRMLS_CC) == SUCCESS) { + //??? return Z_STR(tmp); + //???} + if (Z_OBJ_HT_P(op)->cast_object) { + if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_STRING TSRMLS_CC) == SUCCESS) { + return Z_STR(tmp); + } + } else if (Z_OBJ_HT_P(op)->get) { + zval *z = Z_OBJ_HT_P(op)->get(op, &tmp TSRMLS_CC); + if (Z_TYPE_P(z) != IS_OBJECT) { + zend_string *str = zval_get_string(z); + zval_ptr_dtor(z); + return str; + } + zval_ptr_dtor(z); } + zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val); + return STR_EMPTY_ALLOC(); } + case IS_REFERENCE: + op = Z_REFVAL_P(op); + goto try_again; default: //??? original code returns bool(0) return STR_EMPTY_ALLOC(); @@ -1547,35 +1559,17 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{ ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - int use_copy1 = 0, use_copy2 = 0; - - if (Z_TYPE_P(op1) != IS_STRING) { - zend_make_printable_zval(op1, &op1_copy, &use_copy1); - } - if (Z_TYPE_P(op2) != IS_STRING) { - zend_make_printable_zval(op2, &op2_copy, &use_copy2); - } - - if (use_copy1) { - op1 = &op1_copy; - } - if (use_copy2) { - op2 = &op2_copy; - } + zend_string *str1 = zval_get_string(op1); + zend_string *str2 = zval_get_string(op2); if (case_insensitive) { - ZVAL_LONG(result, zend_binary_zval_strcasecmp(op1, op2)); + ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len)); } else { - ZVAL_LONG(result, zend_binary_zval_strcmp(op1, op2)); + ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len)); } - if (use_copy1) { - zval_dtor(op1); - } - if (use_copy2) { - zval_dtor(op2); - } + STR_RELEASE(str1); + STR_RELEASE(str2); return SUCCESS; } /* }}} */ @@ -1595,31 +1589,13 @@ ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSR #if HAVE_STRCOLL ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - int use_copy1 = 0, use_copy2 = 0; + zend_string *str1 = zval_get_string(op1); + zend_string *str2 = zval_get_string(op2); - if (Z_TYPE_P(op1) != IS_STRING) { - zend_make_printable_zval(op1, &op1_copy, &use_copy1); - } - if (Z_TYPE_P(op2) != IS_STRING) { - zend_make_printable_zval(op2, &op2_copy, &use_copy2); - } + ZVAL_LONG(result, strcoll(str1->val, str2->val)); - if (use_copy1) { - op1 = &op1_copy; - } - if (use_copy2) { - op2 = &op2_copy; - } - - ZVAL_LONG(result, strcoll(Z_STRVAL_P(op1), Z_STRVAL_P(op2))); - - if (use_copy1) { - zval_dtor(op1); - } - if (use_copy2) { - zval_dtor(op2); - } + STR_RELEASE(str1); + STR_RELEASE(str2); return SUCCESS; } /* }}} */ @@ -2424,7 +2400,7 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */ } } else { string_cmp: - Z_LVAL_P(result) = zend_binary_zval_strcmp(s1, s2); + Z_LVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result))); } } diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index c062cd5e19..f026ae1dbc 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -339,7 +339,10 @@ ZEND_API void multi_convert_to_string_ex(int argc, ...); ZEND_API long zval_get_long(zval *op TSRMLS_DC); ZEND_API double zval_get_double(zval *op TSRMLS_DC); -ZEND_API zend_string *zval_get_string(zval *op TSRMLS_DC); +ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC); + +#define zval_get_string(op) ((Z_TYPE_P(op) == IS_STRING) ? \ + STR_COPY(Z_STR_P(op)) : _zval_get_string_func((op) TSRMLS_CC)) ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2); ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2); @@ -370,6 +373,7 @@ ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length); ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2); ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length); +ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2); ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length); ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2); diff --git a/Zend/zend_string.c b/Zend/zend_string.c index 730312009d..80571ec390 100644 --- a/Zend/zend_string.c +++ b/Zend/zend_string.c @@ -46,11 +46,11 @@ void zend_interned_strings_init(TSRMLS_D) zend_string *str; #ifndef ZTS - zend_hash_init(&CG(interned_strings), 0, NULL, _str_dtor, 1); + zend_hash_init(&CG(interned_strings), 1024, NULL, _str_dtor, 1); CG(interned_strings).nTableMask = CG(interned_strings).nTableSize - 1; - CG(interned_strings).arData = (Bucket*) pecalloc(CG(interned_strings).nTableSize, sizeof(Bucket), CG(interned_strings).flags & HASH_FLAG_PERSISTENT); - CG(interned_strings).arHash = (zend_uint*) pecalloc(CG(interned_strings).nTableSize, sizeof(zend_uint), CG(interned_strings).flags & HASH_FLAG_PERSISTENT); + CG(interned_strings).arData = (Bucket*) pecalloc(CG(interned_strings).nTableSize, sizeof(Bucket), 1); + CG(interned_strings).arHash = (zend_uint*) pecalloc(CG(interned_strings).nTableSize, sizeof(zend_uint), 1); memset(CG(interned_strings).arHash, INVALID_IDX, CG(interned_strings).nTableSize * sizeof(zend_uint)); /* interned empty string */ @@ -112,8 +112,8 @@ static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC) if (CG(interned_strings).nNumUsed >= CG(interned_strings).nTableSize) { if ((CG(interned_strings).nTableSize << 1) > 0) { /* Let's double the table size */ - Bucket *d = (Bucket *) perealloc_recoverable(CG(interned_strings).arData, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket), CG(interned_strings).flags & HASH_FLAG_PERSISTENT); - zend_uint *h = (zend_uint *) perealloc_recoverable(CG(interned_strings).arHash, (CG(interned_strings).nTableSize << 1) * sizeof(zend_uint), CG(interned_strings).flags & HASH_FLAG_PERSISTENT); + Bucket *d = (Bucket *) perealloc_recoverable(CG(interned_strings).arData, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket), 1); + zend_uint *h = (zend_uint *) perealloc_recoverable(CG(interned_strings).arHash, (CG(interned_strings).nTableSize << 1) * sizeof(zend_uint), 1); if (d && h) { HANDLE_BLOCK_INTERRUPTIONS(); diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c index 776f728718..92cd62128e 100644 --- a/Zend/zend_ts_hash.c +++ b/Zend/zend_ts_hash.c @@ -59,24 +59,24 @@ static void end_write(TsHashTable *ht) } /* delegates */ -ZEND_API int _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC) +ZEND_API void _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC) { #ifdef ZTS ht->mx_reader = tsrm_mutex_alloc(); ht->mx_writer = tsrm_mutex_alloc(); ht->reader = 0; #endif - return _zend_hash_init(TS_HASH(ht), nSize, pDestructor, persistent ZEND_FILE_LINE_RELAY_CC); + _zend_hash_init(TS_HASH(ht), nSize, pDestructor, persistent ZEND_FILE_LINE_RELAY_CC); } -ZEND_API int _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC) +ZEND_API void _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC) { #ifdef ZTS ht->mx_reader = tsrm_mutex_alloc(); ht->mx_writer = tsrm_mutex_alloc(); ht->reader = 0; #endif - return _zend_hash_init_ex(TS_HASH(ht), nSize, pDestructor, persistent, bApplyProtection ZEND_FILE_LINE_RELAY_CC); + _zend_hash_init_ex(TS_HASH(ht), nSize, pDestructor, persistent, bApplyProtection ZEND_FILE_LINE_RELAY_CC); } ZEND_API void zend_ts_hash_destroy(TsHashTable *ht) diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h index 7394efd576..4b0a507368 100644 --- a/Zend/zend_ts_hash.h +++ b/Zend/zend_ts_hash.h @@ -37,8 +37,8 @@ BEGIN_EXTERN_C() #define TS_HASH(table) (&(table->hash)) /* startup/shutdown */ -ZEND_API int _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC); -ZEND_API int _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC); +ZEND_API void _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC); +ZEND_API void _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC); ZEND_API void zend_ts_hash_destroy(TsHashTable *ht); ZEND_API void zend_ts_hash_clean(TsHashTable *ht); diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 0142e53c40..2afd54f0ec 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -158,8 +158,15 @@ typedef struct _HashTable { zend_uint *arHash; dtor_func_t pDestructor; zend_uint nInternalPointer; - zend_uchar flags; - zend_uchar nApplyCount; + union { + struct { + ZEND_ENDIAN_LOHI_3( + zend_uchar flags, + zend_uchar nApplyCount, + zend_ushort reserve) + } v; + zend_uint flags; + } u; } HashTable; struct _zend_array { diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c index 32fb706982..5557c7beea 100644 --- a/Zend/zend_variables.c +++ b/Zend/zend_variables.c @@ -270,16 +270,14 @@ ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC) } -ZEND_API int zend_print_variable(zval *var) +ZEND_API int zend_print_variable(zval *var TSRMLS_DC) { - return zend_print_zval(var, 0); + return zend_print_zval(var, 0 TSRMLS_CC); } ZEND_API void _zval_dtor_wrapper(zval *zvalue) { - TSRMLS_FETCH(); - zval_dtor(zvalue); } diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h index 686c57ecf2..b85ef435ca 100644 --- a/Zend/zend_variables.h +++ b/Zend/zend_variables.h @@ -64,7 +64,7 @@ static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_D ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key); -ZEND_API int zend_print_variable(zval *var); +ZEND_API int zend_print_variable(zval *var TSRMLS_DC); ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC); ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC); ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e3b58bcea8..63e4165669 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -185,8 +185,8 @@ ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV) SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R), - GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC)); + GET_OP1_ZVAL_PTR(BP_VAR_R), + GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC)); FREE_OP1(); FREE_OP2(); CHECK_EXCEPTION(); @@ -201,8 +201,8 @@ ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV) SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R), - GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC)); + GET_OP1_ZVAL_PTR(BP_VAR_R), + GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC)); FREE_OP1(); FREE_OP2(); CHECK_EXCEPTION(); @@ -217,8 +217,8 @@ ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV) SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R), - GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC)); + GET_OP1_ZVAL_PTR(BP_VAR_R), + GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC)); FREE_OP1(); FREE_OP2(); CHECK_EXCEPTION(); @@ -233,8 +233,8 @@ ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R), - GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC)); + GET_OP1_ZVAL_PTR(BP_VAR_R), + GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC)); FREE_OP1(); FREE_OP2(); CHECK_EXCEPTION(); @@ -470,7 +470,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMP|VAR Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -523,7 +522,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -870,6 +868,14 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_increment_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -899,7 +905,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -920,6 +926,14 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_decrement_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -949,7 +963,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -970,6 +984,12 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_increment_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -1001,7 +1021,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } FREE_OP1_VAR_PTR(); @@ -1018,6 +1038,12 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_decrement_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -1049,7 +1075,7 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } FREE_OP1_VAR_PTR(); @@ -1066,7 +1092,7 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY) SAVE_OPLINE(); z = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); FREE_OP1(); CHECK_EXCEPTION(); @@ -1798,6 +1824,7 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) HANDLE_EXCEPTION_LEAVE(); } + LOAD_OPLINE(); ZEND_VM_INC_OPCODE(); ZEND_VM_LEAVE(); } else if (frame_kind == VM_FRAME_NESTED_CODE) { @@ -1817,6 +1844,7 @@ ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) HANDLE_EXCEPTION_LEAVE(); } + LOAD_OPLINE(); ZEND_VM_INC_OPCODE(); ZEND_VM_LEAVE(); } else { @@ -2863,13 +2891,14 @@ ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ZVAL_COPY_VALUE(&exception, value); - if (!IS_OP1_TMP_FREE()) { - zval_opt_copy_ctor(&exception); + if (OP1_TYPE == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (OP1_TYPE != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(&exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); FREE_OP1_IF_VAR(); HANDLE_EXCEPTION(); @@ -4503,7 +4532,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int prop_dim) +ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -4516,7 +4545,7 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST| container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_IS); offset = GET_OP2_ZVAL_PTR(BP_VAR_R); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -4561,25 +4590,16 @@ ZEND_VM_C_LABEL(str_index_prop): result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -4614,14 +4634,37 @@ ZEND_VM_C_LABEL(str_index_prop): ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV) -{ - ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 0); -} - ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV) { - ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 1); + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_IS); + offset = GET_OP2_ZVAL_PTR(BP_VAR_R); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + FREE_OP2(); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + FREE_OP1_IF_VAR(); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY) @@ -4637,7 +4680,7 @@ ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } FREE_OP1(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 482ea3109d..af9b09dfd2 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -433,6 +433,7 @@ static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) HANDLE_EXCEPTION_LEAVE(); } + LOAD_OPLINE(); ZEND_VM_INC_OPCODE(); ZEND_VM_LEAVE(); } else if (frame_kind == VM_FRAME_NESTED_CODE) { @@ -452,6 +453,7 @@ static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) HANDLE_EXCEPTION_LEAVE(); } + LOAD_OPLINE(); ZEND_VM_INC_OPCODE(); ZEND_VM_LEAVE(); } else { @@ -2337,7 +2339,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = opline->op1.zv; - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -2638,13 +2640,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ZVAL_COPY_VALUE(&exception, value); - if (!0) { - zval_opt_copy_ctor(&exception); + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_CONST != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(&exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -3134,7 +3137,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -5136,7 +5139,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, opline->op1.zv, - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -5152,7 +5155,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, opline->op1.zv, - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -5168,7 +5171,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, opline->op1.zv, - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -5184,7 +5187,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_O SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, opline->op1.zv, - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -6727,7 +6730,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -6743,7 +6746,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -6759,7 +6762,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, opline->op1.zv, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -6775,7 +6778,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -7297,7 +7300,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -7585,13 +7588,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ZVAL_COPY_VALUE(&exception, value); - if (!1) { - zval_opt_copy_ctor(&exception); + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(&exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -8082,7 +8086,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } zval_dtor(free_op1.var); } @@ -9995,7 +9999,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -10011,7 +10015,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -10027,7 +10031,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -10043,7 +10047,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPC SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -11454,7 +11458,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11470,7 +11474,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11486,7 +11490,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11502,7 +11506,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCO SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11969,6 +11973,14 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_increment_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -11998,7 +12010,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -12019,6 +12031,14 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_decrement_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -12048,7 +12068,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -12069,6 +12089,12 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_increment_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -12100,7 +12126,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; @@ -12117,6 +12143,12 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_decrement_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -12148,7 +12180,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; @@ -12165,7 +12197,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -12454,13 +12486,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ZVAL_COPY_VALUE(&exception, value); - if (!0) { - zval_opt_copy_ctor(&exception); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(&exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); zval_ptr_dtor_nogc(free_op1.var); HANDLE_EXCEPTION(); @@ -13211,7 +13244,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } zval_ptr_dtor_nogc(free_op1.var); } @@ -13498,7 +13531,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); @@ -13514,7 +13547,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); @@ -13530,7 +13563,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); @@ -13546,7 +13579,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_O SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); @@ -13756,7 +13789,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(int (*b Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -13809,7 +13841,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binar Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -15380,7 +15411,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; @@ -15393,7 +15424,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST( container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -15438,25 +15469,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -15490,14 +15512,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15791,7 +15835,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); @@ -15807,7 +15851,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); @@ -15823,7 +15867,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); @@ -15839,7 +15883,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPC SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); @@ -16050,7 +16094,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(int (*bin Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -16103,7 +16146,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_ Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -17288,7 +17330,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -17301,7 +17343,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(in container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -17346,25 +17388,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -17399,14 +17432,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17700,8 +17756,8 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -17716,8 +17772,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -17732,8 +17788,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -17748,8 +17804,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPC SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -17959,7 +18015,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(int (*bin Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -18012,7 +18067,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_ Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -19558,7 +19612,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; @@ -19571,7 +19625,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(in container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -19616,25 +19670,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -19669,14 +19714,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -19952,7 +20020,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(int (* Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -20005,7 +20072,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -21117,8 +21183,8 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -21133,8 +21199,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -21149,8 +21215,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -21165,8 +21231,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCO SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); @@ -21375,7 +21441,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CV(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -21428,7 +21493,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_o Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -22668,7 +22732,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; @@ -22681,7 +22745,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -22726,25 +22790,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -22778,14 +22833,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -22990,7 +23067,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -23140,7 +23217,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(int Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -23193,7 +23269,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*bi Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -24061,7 +24136,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -24074,7 +24149,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -24119,25 +24194,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -24171,14 +24237,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -24453,7 +24541,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(int (* Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -24506,7 +24593,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -25289,7 +25375,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; @@ -25302,7 +25388,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -25347,25 +25433,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -25400,14 +25477,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -25682,7 +25782,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(int (* Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -25735,7 +25834,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -26518,7 +26616,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; @@ -26531,7 +26629,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -26576,25 +26674,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -26629,14 +26718,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -26910,7 +27022,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(int Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -26963,7 +27074,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*b Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -27406,7 +27516,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(int (*b Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -27459,7 +27568,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binar Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -28236,7 +28344,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -28249,7 +28357,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV( container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -28294,25 +28402,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -28346,14 +28445,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -28521,6 +28642,14 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_increment_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -28550,7 +28679,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -28570,6 +28699,14 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_decrement_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -28599,7 +28736,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { @@ -28619,6 +28756,12 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_increment_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -28650,7 +28793,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_increment_function(var_ptr); + increment_function(var_ptr); } CHECK_EXCEPTION(); @@ -28666,6 +28809,12 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_decrement_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } @@ -28697,7 +28846,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); zval_ptr_dtor(val); } else { - fast_decrement_function(var_ptr); + decrement_function(var_ptr); } CHECK_EXCEPTION(); @@ -28713,7 +28862,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -28986,13 +29135,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ZVAL_COPY_VALUE(&exception, value); - if (!0) { - zval_opt_copy_ctor(&exception); + if (IS_CV == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_CV != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(&exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -29592,7 +29742,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -29876,7 +30026,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC)); @@ -29892,7 +30042,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC)); @@ -29908,7 +30058,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC)); @@ -29924,7 +30074,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC)); @@ -30133,7 +30283,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CONST(int (*bi Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -30186,7 +30335,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -31546,7 +31694,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -31559,7 +31707,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(i container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -31604,25 +31752,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -31656,14 +31795,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -31956,7 +32117,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op2.var); @@ -31972,7 +32133,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op2.var); @@ -31988,7 +32149,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op2.var); @@ -32004,7 +32165,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCO SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_dtor(free_op2.var); @@ -32214,7 +32375,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_TMP(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -32267,7 +32427,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_o Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -33337,7 +33496,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; @@ -33350,7 +33509,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -33395,25 +33554,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -33448,14 +33598,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -33748,8 +33921,8 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -33764,8 +33937,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -33780,8 +33953,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -33796,8 +33969,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCO SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); @@ -34006,7 +34179,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_VAR(int (*bina Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -34059,7 +34231,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_o Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -35489,7 +35660,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; @@ -35502,7 +35673,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -35547,25 +35718,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -35600,14 +35762,37 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -35881,7 +36066,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(int (*b Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -35934,7 +36118,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binar Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -36913,8 +37096,8 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -36929,8 +37112,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -36945,8 +37128,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -36961,8 +37144,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD SAVE_OPLINE(); ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); CHECK_EXCEPTION(); @@ -37170,7 +37353,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CV(int (*binar Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -37223,7 +37405,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); zval_ptr_dtor(objval); } else { - ZVAL_DEREF(var_ptr); binary_op(var_ptr, var_ptr, value TSRMLS_CC); } @@ -38347,7 +38528,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -38360,7 +38541,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { + if (Z_TYPE_P(container) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(container); zval *value = NULL; zend_string *str; @@ -38405,25 +38586,16 @@ str_index_prop: result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; result = 0; @@ -38457,14 +38629,36 @@ str_index_prop: ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/ext/dom/attr.c b/ext/dom/attr.c index 63be8762d1..b0489ef122 100644 --- a/ext/dom/attr.c +++ b/ext/dom/attr.c @@ -171,7 +171,7 @@ int dom_attr_value_write(dom_object *obj, zval *newval TSRMLS_DC) node_list_unlink(attrp->children TSRMLS_CC); } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); xmlNodeSetContentLen((xmlNodePtr) attrp, str->val, str->len + 1); diff --git a/ext/dom/characterdata.c b/ext/dom/characterdata.c index b1b5d76d26..2ef6352f20 100644 --- a/ext/dom/characterdata.c +++ b/ext/dom/characterdata.c @@ -106,7 +106,7 @@ int dom_characterdata_data_write(dom_object *obj, zval *newval TSRMLS_DC) return FAILURE; } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); xmlNodeSetContentLen(nodep, str->val, str->len + 1); diff --git a/ext/dom/document.c b/ext/dom/document.c index 35d8348a2d..b1c1dc2737 100644 --- a/ext/dom/document.c +++ b/ext/dom/document.c @@ -338,7 +338,7 @@ int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC) return FAILURE; } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); handler = xmlFindCharEncodingHandler(Z_STRVAL_P(newval)); @@ -436,7 +436,7 @@ int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC) xmlFree((xmlChar *) docp->version ); } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); docp->version = xmlStrdup((const xmlChar *) str->val); @@ -664,7 +664,7 @@ int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC) xmlFree((xmlChar *) docp->URL); } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); docp->URL = xmlStrdup((const xmlChar *) str->val); diff --git a/ext/dom/node.c b/ext/dom/node.c index 57669b5069..25c8daee6f 100644 --- a/ext/dom/node.c +++ b/ext/dom/node.c @@ -343,7 +343,7 @@ int dom_node_node_value_write(dom_object *obj, zval *newval TSRMLS_DC) case XML_CDATA_SECTION_NODE: case XML_PI_NODE: { - zend_string *str = zval_get_string(newval TSRMLS_CC); + zend_string *str = zval_get_string(newval); xmlNodeSetContentLen(nodep, str->val, str->len + 1); STR_RELEASE(str); break; @@ -720,7 +720,7 @@ int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC) nsnode = xmlDocGetRootElement(nodep->doc); } } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); prefix = str->val; if (nsnode && nodep->ns != NULL && !xmlStrEqual(nodep->ns->prefix, (xmlChar *)prefix)) { strURI = (char *) nodep->ns->href; diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c index 99d99e236f..9f971ee0ac 100644 --- a/ext/dom/php_dom.c +++ b/ext/dom/php_dom.c @@ -313,7 +313,7 @@ static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_r static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */ { dom_object *obj = Z_DOMOBJ_P(object); - zend_string *member_str = zval_get_string(member TSRMLS_CC); + zend_string *member_str = zval_get_string(member); zval *retval = NULL; if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, member_str)) { @@ -330,7 +330,7 @@ static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, zend zval *dom_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) { dom_object *obj = Z_DOMOBJ_P(object); - zend_string *member_str = zval_get_string(member TSRMLS_CC); + zend_string *member_str = zval_get_string(member); zval *retval; dom_prop_handler *hnd = NULL; @@ -361,7 +361,7 @@ zval *dom_read_property(zval *object, zval *member, int type, zend_uint cache_sl void dom_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) { dom_object *obj = Z_DOMOBJ_P(object); - zend_string *member_str = zval_get_string(member TSRMLS_CC); + zend_string *member_str = zval_get_string(member); dom_prop_handler *hnd = NULL; if (obj->prop_handler != NULL) { @@ -382,7 +382,7 @@ void dom_write_property(zval *object, zval *member, zval *value, zend_uint cache static int dom_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC) { dom_object *obj = Z_DOMOBJ_P(object); - zend_string *member_str = zval_get_string(member TSRMLS_CC); + zend_string *member_str = zval_get_string(member); dom_prop_handler *hnd = NULL; int retval = 0; diff --git a/ext/dom/processinginstruction.c b/ext/dom/processinginstruction.c index aef9e92b64..36b159cc6e 100644 --- a/ext/dom/processinginstruction.c +++ b/ext/dom/processinginstruction.c @@ -145,7 +145,7 @@ int dom_processinginstruction_data_write(dom_object *obj, zval *newval TSRMLS_DC return FAILURE; } - str = zval_get_string(newval TSRMLS_CC); + str = zval_get_string(newval); xmlNodeSetContentLen(nodep, str->val, str->len + 1); diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c index 08bb8603a5..3290a3a5e7 100644 --- a/ext/dom/xpath.c +++ b/ext/dom/xpath.c @@ -522,7 +522,7 @@ PHP_FUNCTION(dom_xpath_register_php_functions) intern = Z_XPATHOBJ_P(id); zend_hash_internal_pointer_reset(Z_ARRVAL_P(array_value)); while ((entry = zend_hash_get_current_data(Z_ARRVAL_P(array_value)))) { - zend_string *str = zval_get_string(entry TSRMLS_CC); + zend_string *str = zval_get_string(entry); ZVAL_LONG(&new_string,1); zend_hash_update(intern->registered_phpfunctions, str, &new_string); zend_hash_move_forward(Z_ARRVAL_P(array_value)); diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index 2260af80bc..51ab3cd97b 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -1038,9 +1038,6 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array, er = EG(error_reporting); EG(error_reporting) = 0; if (binary_op(&result, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline) TSRMLS_CC) == SUCCESS) { -//??? PZ_SET_REFCOUNT_P(&result, 1); -//??? PZ_UNSET_ISREF_P(&result); - literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP2_LITERAL(opline)); opline->opcode = ZEND_QM_ASSIGN; @@ -1068,8 +1065,6 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array, convert_to_boolean(&result); ZVAL_NULL(&ZEND_OP1_LITERAL(opline)); } -//??? PZ_SET_REFCOUNT_P(&result, 1); -//??? PZ_UNSET_ISREF_P(&result); opline->opcode = ZEND_QM_ASSIGN; update_op1_const(op_array, opline, &result TSRMLS_CC); } else if ((opline->opcode == ZEND_RETURN || opline->opcode == ZEND_EXIT) && @@ -1654,11 +1649,6 @@ next_target: char *same_t=NULL; zend_code_block *target_block; int var_num = op_array->last_var + op_array->T; -//??? if (op_array->T >= (zend_uint)op_array->last_var) { -//??? var_num = op_array->T; -//??? } else { -//??? var_num = op_array->last_var; -//??? } if (var_num <= 0) { return; diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c index 6c3bf41ec3..59628243f6 100644 --- a/ext/opcache/Optimizer/compact_literals.c +++ b/ext/opcache/Optimizer/compact_literals.c @@ -396,13 +396,6 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC) op_array->literals[j] = op_array->literals[i]; info[j] = info[i]; } -//??? if (!Z_STR(op_array->literals[j].hash_value) { -//??? if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) { -//??? op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant)); -//??? } else { -//??? op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1); -//??? } -//??? } if (LITERAL_NUM_SLOTS(info[i].flags)) { Z_CACHE_SLOT(op_array->literals[j]) = cache_slots; cache_slots += LITERAL_NUM_SLOTS(info[i].flags); @@ -412,13 +405,6 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC) while (n > 1) { i++; if (i != j) op_array->literals[j] = op_array->literals[i]; -//??? if (!op_array->literals[j].hash_value) { -//??? if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) { -//??? op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant)); -//??? } else { -//??? op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1); -//??? } -//??? } j++; n--; } diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c index 207b8d0e61..4e1410a76e 100644 --- a/ext/opcache/Optimizer/pass1_5.c +++ b/ext/opcache/Optimizer/pass1_5.c @@ -60,9 +60,6 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) { break; } EG(error_reporting) = er; -//??? PZ_SET_REFCOUNT_P(&result, 1); -//??? PZ_UNSET_ISREF_P(&result); - literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP2_LITERAL(opline)); MAKE_NOP(opline); @@ -134,9 +131,6 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) { break; } EG(error_reporting) = er; -//??? PZ_SET_REFCOUNT_P(&result, 1); -//??? PZ_UNSET_ISREF_P(&result); - literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index 0498bcba07..39f7b01eea 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -170,24 +170,20 @@ static void update_op1_const(zend_op_array *op_array, case ZEND_FETCH_CONSTANT: opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline))); -//??? Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1); Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++; zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val)); zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(op_array->literals[opline->op1.constant+1])); -//??? op_array->literals[opline->op1.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op1.constant+1].constant), Z_STRLEN(op_array->literals[opline->op1.constant+1].constant) + 1); break; case ZEND_DO_FCALL: zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val)); opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline))); -//??? Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1); Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++; break; default: opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline))); -//??? Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1); break; } } else { @@ -208,7 +204,6 @@ static void update_op2_const(zend_op_array *op_array, opline->op2.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC); if (Z_TYPE_P(val) == IS_STRING) { STR_HASH_VAL(Z_STR(ZEND_OP2_LITERAL(opline))); -//??? Z_HASH_P(&ZEND_OP2_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)) + 1); switch (opline->opcode) { case ZEND_FETCH_R: case ZEND_FETCH_W: @@ -227,14 +222,12 @@ static void update_op2_const(zend_op_array *op_array, zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val)); zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1])); -//??? op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1); break; case ZEND_INIT_METHOD_CALL: case ZEND_INIT_STATIC_METHOD_CALL: zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val)); zend_optimizer_add_literal(op_array, val TSRMLS_CC); STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1])); -//??? op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1); /* break missing intentionally */ /*case ZEND_FETCH_CONSTANT:*/ case ZEND_ASSIGN_OBJ: diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index 01dfd5c2a9..84c397d7ab 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -1247,6 +1247,8 @@ static const struct jit_auto_global_info #endif }; +static zend_string *jit_auto_globals_str[4]; + static int zend_accel_get_auto_globals(TSRMLS_D) { int i, ag_size = (sizeof(jit_auto_globals_info) / sizeof(jit_auto_globals_info[0])); @@ -1254,7 +1256,7 @@ static int zend_accel_get_auto_globals(TSRMLS_D) int mask = 0; for (i = 0; i < ag_size ; i++) { - if (zend_hash_str_exists(&EG(symbol_table).ht, jit_auto_globals_info[i].name, jit_auto_globals_info[i].len)) { + if (zend_hash_exists(&EG(symbol_table).ht, jit_auto_globals_str[i])) { mask |= n; } n += n; @@ -1265,7 +1267,7 @@ static int zend_accel_get_auto_globals(TSRMLS_D) #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO static int zend_accel_get_auto_globals_no_jit(TSRMLS_D) { - if (zend_hash_str_exists(&EG(symbol_table).ht, jit_auto_globals_info[3].name, jit_auto_globals_info[3].len)) { + if (zend_hash_exists(&EG(symbol_table).ht, jit_auto_globals_str[3])) { return 8; } return 0; @@ -1276,19 +1278,26 @@ static void zend_accel_set_auto_globals(int mask TSRMLS_DC) { int i, ag_size = (sizeof(jit_auto_globals_info) / sizeof(jit_auto_globals_info[0])); int n = 1; - zend_string *str; for (i = 0; i < ag_size ; i++) { if (mask & n) { -//??? - str = STR_INIT(jit_auto_globals_info[i].name, jit_auto_globals_info[i].len, 0); - zend_is_auto_global(str TSRMLS_CC); - STR_RELEASE(str); + zend_is_auto_global(jit_auto_globals_str[i] TSRMLS_CC); } n += n; } } +static void zend_accel_init_auto_globals(TSRMLS_D) +{ + int i, ag_size = (sizeof(jit_auto_globals_info) / sizeof(jit_auto_globals_info[0])); + + for (i = 0; i < ag_size ; i++) { + jit_auto_globals_str[i] = STR_INIT(jit_auto_globals_info[i].name, jit_auto_globals_info[i].len, 1); + STR_HASH_VAL(jit_auto_globals_str[i]); + jit_auto_globals_str[i] = accel_new_interned_string(jit_auto_globals_str[i] TSRMLS_CC); + } +} + static zend_persistent_script *compile_and_cache_file(zend_file_handle *file_handle, int type, char *key, unsigned int key_length, zend_op_array **op_array_p, int *from_shared_memory TSRMLS_DC) { zend_persistent_script *new_persistent_script; @@ -2342,7 +2351,7 @@ static void zend_accel_fast_shutdown(TSRMLS_D) } zend_end_try(); EG(symbol_table).ht.pDestructor = old_destructor; } - zend_hash_init(&EG(symbol_table).ht, 0, NULL, NULL, 0); + zend_hash_init(&EG(symbol_table).ht, 8, NULL, NULL, 0); old_destructor = EG(function_table)->pDestructor; EG(function_table)->pDestructor = NULL; zend_hash_reverse_apply(EG(function_table), (apply_func_t) accel_clean_non_persistent_function TSRMLS_CC); @@ -2624,6 +2633,9 @@ static int accel_startup(zend_extension *extension) /* from this point further, shared memory is supposed to be OK */ + /* Init auto-global strings */ + zend_accel_init_auto_globals(TSRMLS_C); + /* Override compiler */ accelerator_orig_compile_file = zend_compile_file; zend_compile_file = persistent_compile_file; diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c index 51051dd6ce..c93bec7994 100644 --- a/ext/opcache/zend_accelerator_util_funcs.c +++ b/ext/opcache/zend_accelerator_util_funcs.c @@ -77,12 +77,12 @@ zend_persistent_script* create_persistent_script(void) zend_persistent_script *persistent_script = (zend_persistent_script *) emalloc(sizeof(zend_persistent_script)); memset(persistent_script, 0, sizeof(zend_persistent_script)); - zend_hash_init(&persistent_script->function_table, 100, NULL, (dtor_func_t) zend_accel_destroy_zend_function, 0); + zend_hash_init(&persistent_script->function_table, 128, NULL, (dtor_func_t) zend_accel_destroy_zend_function, 0); /* class_table is usually destroyed by free_persistent_script() that * overrides destructor. ZEND_CLASS_DTOR may be used by standard * PHP compiler */ - zend_hash_init(&persistent_script->class_table, 10, NULL, ZEND_CLASS_DTOR, 0); + zend_hash_init(&persistent_script->class_table, 16, NULL, ZEND_CLASS_DTOR, 0); return persistent_script; } @@ -95,7 +95,7 @@ static int compact_hash_table(HashTable *ht) Bucket *d; Bucket *p; - if (!ht->nNumOfElements || (ht->flags & HASH_FLAG_PACKED)) { + if (!ht->nNumOfElements || (ht->u.flags & HASH_FLAG_PACKED)) { /* Empty tables don't allocate space for Buckets */ return 1; } @@ -115,7 +115,7 @@ static int compact_hash_table(HashTable *ht) return 1; } - d = (Bucket *)pemalloc(nSize * (sizeof(Bucket) + sizeof(zend_uint)), ht->flags & HASH_FLAG_PERSISTENT); + d = (Bucket *)pemalloc(nSize * (sizeof(Bucket) + sizeof(zend_uint)), ht->u.flags & HASH_FLAG_PERSISTENT); if (!d) { return 0; } @@ -128,7 +128,7 @@ static int compact_hash_table(HashTable *ht) } ht->nNumUsed = j; - pefree(ht->arData, ht->flags & HASH_FLAG_PERSISTENT); + pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT); ht->arData = d; ht->arHash = (zend_uint *)(d + nSize); @@ -360,11 +360,10 @@ static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind) ht->nNumOfElements = source->nNumOfElements; ht->nNextFreeElement = source->nNextFreeElement; ht->pDestructor = ZVAL_PTR_DTOR; - ht->flags = HASH_FLAG_APPLY_PROTECTION; + ht->u.flags = HASH_FLAG_APPLY_PROTECTION; ht->arData = NULL; ht->arHash = NULL; ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX; - ht->nApplyCount = 0; #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO if (!ht->nTableMask) { @@ -373,8 +372,8 @@ static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind) } #endif - if (source->flags & HASH_FLAG_PACKED) { - ht->flags |= HASH_FLAG_PACKED; + if (source->u.flags & HASH_FLAG_PACKED) { + ht->u.flags |= HASH_FLAG_PACKED; ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket)); ht->arHash = (zend_uint*)&uninitialized_bucket; } else { @@ -389,7 +388,7 @@ static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind) nIndex = p->h & ht->nTableMask; /* Insert into hash collision list */ - if (source->flags & HASH_FLAG_PACKED) { + if (source->u.flags & HASH_FLAG_PACKED) { Bucket *r = ht->arData + ht->nNumUsed; q = ht->arData + p->h; while (r != q) { @@ -432,9 +431,8 @@ static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class ht->nNumOfElements = source->nNumOfElements; ht->nNextFreeElement = source->nNextFreeElement; ht->pDestructor = ZEND_FUNCTION_DTOR; - ht->flags = HASH_FLAG_APPLY_PROTECTION; + ht->u.flags = HASH_FLAG_APPLY_PROTECTION; ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX; - ht->nApplyCount = 0; #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO if (!ht->nTableMask) { @@ -443,8 +441,8 @@ static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class } #endif - if (source->flags & HASH_FLAG_PACKED) { - ht->flags |= HASH_FLAG_PACKED; + if (source->u.flags & HASH_FLAG_PACKED) { + ht->u.flags |= HASH_FLAG_PACKED; ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket)); ht->arHash = (zend_uint*)&uninitialized_bucket; } else { @@ -460,7 +458,7 @@ static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class nIndex = p->h & ht->nTableMask; /* Insert into hash collision list */ - if (source->flags & HASH_FLAG_PACKED) { + if (source->u.flags & HASH_FLAG_PACKED) { Bucket *r = ht->arData + ht->nNumUsed; q = ht->arData + p->h; while (r != q) { @@ -530,9 +528,8 @@ static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_cla ht->nNumOfElements = source->nNumOfElements; ht->nNextFreeElement = source->nNextFreeElement; ht->pDestructor = zend_destroy_property_info; - ht->flags = HASH_FLAG_APPLY_PROTECTION; + ht->u.flags = HASH_FLAG_APPLY_PROTECTION; ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX; - ht->nApplyCount = 0; #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO if (!ht->nTableMask) { @@ -541,9 +538,9 @@ static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_cla } #endif - if (source->flags & HASH_FLAG_PACKED) { + if (source->u.flags & HASH_FLAG_PACKED) { ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket)); - ht->flags |= HASH_FLAG_PACKED; + ht->u.flags |= HASH_FLAG_PACKED; ht->arHash = (zend_uint*)&uninitialized_bucket; } else { ht->arData = (Bucket *) emalloc(ht->nTableSize * (sizeof(Bucket) + sizeof(zend_uint))); @@ -558,7 +555,7 @@ static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_cla nIndex = p->h & ht->nTableMask; /* Insert into hash collision list */ - if (source->flags & HASH_FLAG_PACKED) { + if (source->u.flags & HASH_FLAG_PACKED) { Bucket *r = ht->arData + ht->nNumUsed; q = ht->arData + p->h; while (r != q) { diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index ca8835c2ed..ca2ad5150c 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -79,7 +79,7 @@ static void zend_hash_persist(HashTable *ht, zend_persist_func_t pPersistElement ht->arHash = (zend_uint*)&uninitialized_bucket; return; } - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { zend_accel_store(ht->arData, sizeof(Bucket) * ht->nTableSize); ht->arHash = (zend_uint*)&uninitialized_bucket; } else { diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 20e6b083c4..6298fb1aa2 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -62,7 +62,7 @@ static uint zend_hash_persist_calc(HashTable *ht, uint (*pPersistElement)(zval * if (!ht->nTableMask) { RETURN_SIZE(); } - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { ADD_DUP_SIZE(ht->arData, sizeof(Bucket) * ht->nTableSize); } else { ADD_DUP_SIZE(ht->arData, (sizeof(Bucket) + sizeof(zend_uint)) * ht->nTableSize); diff --git a/ext/opcache/zend_shared_alloc.c b/ext/opcache/zend_shared_alloc.c index 4a31d3de6a..0faabee8b2 100644 --- a/ext/opcache/zend_shared_alloc.c +++ b/ext/opcache/zend_shared_alloc.c @@ -402,7 +402,7 @@ void zend_shared_alloc_lock(TSRMLS_D) * won't be taken from space which is freed by efree in memdup. * Otherwise it leads to false matches in memdup check. */ - zend_hash_init(&xlat_table, 100, NULL, NULL, 1); + zend_hash_init(&xlat_table, 128, NULL, NULL, 1); } void zend_shared_alloc_unlock(TSRMLS_D) diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index d2a6790d6b..4940457333 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -655,23 +655,13 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in /* {{{ _const_string */ static void _const_string(string *str, char *name, zval *value, char *indent TSRMLS_DC) { - char *type; - zval value_copy; - int use_copy; - - type = zend_zval_type_name(value); - - zend_make_printable_zval(value, &value_copy, &use_copy); - if (use_copy) { - value = &value_copy; - } + char *type = zend_zval_type_name(value); + zend_string *value_str = zval_get_string(value); string_printf(str, "%s Constant [ %s %s ] { %s }\n", - indent, type, name, Z_STRVAL_P(value)); + indent, type, name, value_str->val); - if (use_copy) { - zval_dtor(value); - } + STR_RELEASE(value_str); } /* }}} */ @@ -728,8 +718,7 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg if (fptr->type == ZEND_USER_FUNCTION && offset >= required) { zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset); if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { - zval zv, zv_copy; - int use_copy; + zval zv; string_write(str, " = ", sizeof(" = ")-1); ZVAL_DUP(&zv, precv->op2.zv); zval_update_constant_ex(&zv, (void*)1, fptr->common.scope TSRMLS_CC); @@ -751,11 +740,9 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg } else if (Z_TYPE(zv) == IS_ARRAY) { string_write(str, "Array", sizeof("Array")-1); } else { - zend_make_printable_zval(&zv, &zv_copy, &use_copy); - string_write(str, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy)); - if (use_copy) { - zval_dtor(&zv_copy); - } + zend_string *zv_str = zval_get_string(&zv); + string_write(str, zv_str->val, zv_str->len); + STR_RELEASE(zv_str); } zval_ptr_dtor(&zv); } @@ -1529,7 +1516,7 @@ ZEND_METHOD(reflection, export) ZVAL_COPY_VALUE(return_value, &retval); } else { /* No need for _r variant, return of __toString should always be a string */ - zend_print_zval(&retval, 0); + zend_print_zval(&retval, 0 TSRMLS_CC); zend_printf("\n"); zval_ptr_dtor(&retval); } @@ -4974,11 +4961,6 @@ ZEND_METHOD(reflection_property, getValue) zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name); member_p = zend_read_property(ref->ce, object, prop_name, strlen(prop_name), 1 TSRMLS_CC); ZVAL_DUP(return_value, member_p); -//??? - if (member_p != &EG(uninitialized_zval)) { - zval_add_ref(member_p); - zval_ptr_dtor(member_p); - } } } /* }}} */ diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 208f9de7a6..eafc280f0e 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -129,7 +129,7 @@ SPL_API int spl_hash_verify_pos_ex(spl_array_object * intern, HashTable * ht TSR /* IS_CONSISTENT(ht);*/ /* HASH_PROTECT_RECURSION(ht);*/ - if (ht->flags & HASH_FLAG_PACKED) { + if (ht->u.flags & HASH_FLAG_PACKED) { if (intern->pos_h == intern->pos && Z_TYPE(ht->arData[intern->pos_h].val) != IS_UNDEF) { return SUCCESS; } @@ -309,7 +309,7 @@ static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval return &EG(uninitialized_zval); } - if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->nApplyCount > 0)) { + if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->u.v.nApplyCount > 0)) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return &EG(error_zval);; } @@ -464,7 +464,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval if (!offset) { ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -481,7 +481,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval switch (Z_TYPE_P(offset)) { case IS_STRING: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -492,7 +492,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval case IS_BOOL: case IS_LONG: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -505,7 +505,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval return; case IS_NULL: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -538,7 +538,7 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval switch(Z_TYPE_P(offset)) { case IS_STRING: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -583,7 +583,7 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval index = Z_LVAL_P(offset); } ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited"); return; } @@ -827,7 +827,7 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0); } - if (intern->debug_info->nApplyCount == 0) { + if (intern->debug_info->u.v.nApplyCount == 0) { zend_hash_clean(intern->debug_info); zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); @@ -1446,27 +1446,27 @@ static void spl_array_method(INTERNAL_FUNCTION_PARAMETERS, char *fname, int fnam *Z_ARRVAL(tmp) = *aht; if (!use_arg) { - aht->nApplyCount++; + aht->u.v.nApplyCount++; zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 1, &tmp, NULL TSRMLS_CC); - aht->nApplyCount--; + aht->u.v.nApplyCount--; } else if (use_arg == SPL_ARRAY_METHOD_MAY_USER_ARG) { if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) { zval_ptr_dtor(&tmp); zend_throw_exception(spl_ce_BadMethodCallException, "Function expects one argument at most", 0 TSRMLS_CC); return; } - aht->nApplyCount++; + aht->u.v.nApplyCount++; zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, arg? 2 : 1, &tmp, arg TSRMLS_CC); - aht->nApplyCount--; + aht->u.v.nApplyCount--; } else { if (ZEND_NUM_ARGS() != 1 || zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { zval_ptr_dtor(&tmp); zend_throw_exception(spl_ce_BadMethodCallException, "Function expects exactly one argument", 0 TSRMLS_CC); return; } - aht->nApplyCount++; + aht->u.v.nApplyCount++; zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 2, &tmp, arg TSRMLS_CC); - aht->nApplyCount--; + aht->u.v.nApplyCount--; } /* A tricky way to pass "aht" by reference, copy back and cleanup */ if (Z_ISREF(tmp) && Z_TYPE_P(Z_REFVAL(tmp))) { diff --git a/ext/spl/spl_dllist.c b/ext/spl/spl_dllist.c index 6bc21ee814..dc10dde6e9 100644 --- a/ext/spl/spl_dllist.c +++ b/ext/spl/spl_dllist.c @@ -514,7 +514,7 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML zend_hash_init(intern->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0); } - if (intern->debug_info->nApplyCount == 0) { + if (intern->debug_info->u.v.nApplyCount == 0) { if (!intern->std.properties) { rebuild_object_properties(&intern->std); diff --git a/ext/spl/spl_heap.c b/ext/spl/spl_heap.c index 55550d6f40..f8ce102967 100644 --- a/ext/spl/spl_heap.c +++ b/ext/spl/spl_heap.c @@ -524,7 +524,7 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0); } - if (intern->debug_info->nApplyCount == 0) { + if (intern->debug_info->u.v.nApplyCount == 0) { zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c index 0b2eee69eb..5abedecb7f 100644 --- a/ext/spl/spl_observer.c +++ b/ext/spl/spl_observer.c @@ -328,7 +328,7 @@ static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_D ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(props) + 1, 0); } - if (intern->debug_info->nApplyCount == 0) { + if (intern->debug_info->u.v.nApplyCount == 0) { zend_hash_copy(intern->debug_info, props, (copy_ctor_func_t)zval_add_ref); array_init(&storage); diff --git a/ext/standard/array.c b/ext/standard/array.c index 03c77fea80..6dada188cf 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -274,7 +274,7 @@ static int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */ zval *element; if (Z_TYPE_P(array) == IS_ARRAY) { - if (Z_ARRVAL_P(array)->nApplyCount > 1) { + if (Z_ARRVAL_P(array)->u.v.nApplyCount > 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); return 0; } @@ -282,10 +282,10 @@ static int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */ cnt = zend_hash_num_elements(Z_ARRVAL_P(array)); if (mode == COUNT_RECURSIVE) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) { - Z_ARRVAL_P(array)->nApplyCount++; + Z_ARRVAL_P(array)->u.v.nApplyCount++; ZVAL_DEREF(element); cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC); - Z_ARRVAL_P(array)->nApplyCount--; + Z_ARRVAL_P(array)->u.v.nApplyCount--; } ZEND_HASH_FOREACH_END(); } } @@ -1089,7 +1089,7 @@ static int php_array_walk(HashTable *target_hash, zval *userdata, int recursive SEPARATE_ZVAL(zv); thash = Z_ARRVAL_P(zv); } - if (thash->nApplyCount > 1) { + if (thash->u.v.nApplyCount > 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); if (userdata) { zval_ptr_dtor(&args[2]); @@ -1101,9 +1101,9 @@ static int php_array_walk(HashTable *target_hash, zval *userdata, int recursive orig_array_walk_fci = BG(array_walk_fci); orig_array_walk_fci_cache = BG(array_walk_fci_cache); - thash->nApplyCount++; + thash->u.v.nApplyCount++; php_array_walk(thash, userdata, recursive TSRMLS_CC); - thash->nApplyCount--; + thash->u.v.nApplyCount--; /* restore the fcall info and cache */ BG(array_walk_fci) = orig_array_walk_fci; @@ -1216,31 +1216,43 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ ulong num_idx; zend_string *str_idx; zend_bool strict = 0; /* strict comparison or not */ - int (*is_equal_func)(zval *, zval *, zval * TSRMLS_DC) = is_equal_function; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za|b", &value, &array, &strict) == FAILURE) { return; } if (strict) { - is_equal_func = is_identical_function; - } - - ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) { - is_equal_func(&res, value, entry TSRMLS_CC); - if (Z_LVAL(res)) { - if (behavior == 0) { - RETURN_TRUE; - } else { - if (str_idx) { - RETVAL_STR(STR_COPY(str_idx)); + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) { + is_identical_function(&res, value, entry TSRMLS_CC); + if (Z_LVAL(res)) { + if (behavior == 0) { + RETURN_TRUE; } else { - RETVAL_LONG(num_idx); + if (str_idx) { + RETVAL_STR(STR_COPY(str_idx)); + } else { + RETVAL_LONG(num_idx); + } + return; } - return; } - } - } ZEND_HASH_FOREACH_END(); + } ZEND_HASH_FOREACH_END(); + } else { + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) { + if (fast_equal_function(&res, value, entry TSRMLS_CC)) { + if (behavior == 0) { + RETURN_TRUE; + } else { + if (str_idx) { + RETVAL_STR(STR_COPY(str_idx)); + } else { + RETVAL_LONG(num_idx); + } + return; + } + } + } ZEND_HASH_FOREACH_END(); + } RETURN_FALSE; } @@ -1475,17 +1487,17 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu zend_hash_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data); } } else if (Z_TYPE_P(entry) == IS_ARRAY) { - if ((Z_ARRVAL_P(entry)->nApplyCount > 1)) { + if ((Z_ARRVAL_P(entry)->u.v.nApplyCount > 1)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); return; } - Z_ARRVAL_P(entry)->nApplyCount++; + Z_ARRVAL_P(entry)->u.v.nApplyCount++; ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(entry), value_ptr) { php_compact_var(eg_active_symbol_table, return_value, value_ptr TSRMLS_CC); } ZEND_HASH_FOREACH_END(); - Z_ARRVAL_P(entry)->nApplyCount--; + Z_ARRVAL_P(entry)->u.v.nApplyCount--; } } /* }}} */ @@ -1797,7 +1809,7 @@ static void php_array_data_shuffle(zval *array TSRMLS_DC) /* {{{ */ p->key = NULL; } hash->nNextFreeElement = n_elems; - if (!(hash->flags & HASH_FLAG_PACKED)) { + if (!(hash->u.flags & HASH_FLAG_PACKED)) { zend_hash_to_packed(hash); } HANDLE_UNBLOCK_INTERRUPTIONS(); @@ -2037,7 +2049,7 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end) } Z_ARRVAL_P(stack)->nNextFreeElement = k; if (should_rehash) { - if (Z_ARRVAL_P(stack)->flags & HASH_FLAG_PACKED) { + if (Z_ARRVAL_P(stack)->u.flags & HASH_FLAG_PACKED) { zend_hash_packed_to_hash(Z_ARRVAL_P(stack)); } else { zend_hash_rehash(Z_ARRVAL_P(stack)); @@ -2272,7 +2284,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS ZVAL_DEREF(src_zval); ZVAL_DEREF(dest_zval); thash = Z_TYPE_P(dest_zval) == IS_ARRAY ? Z_ARRVAL_P(dest_zval) : NULL; - if ((thash && thash->nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) { + if ((thash && thash->u.v.nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); return 0; } @@ -2303,16 +2315,16 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS } if (Z_TYPE_P(src_zval) == IS_ARRAY) { if (thash) { - thash->nApplyCount++; + thash->u.v.nApplyCount++; } if (!php_array_merge(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval), recursive TSRMLS_CC)) { if (thash) { - thash->nApplyCount--; + thash->u.v.nApplyCount--; } return 0; } if (thash) { - thash->nApplyCount--; + thash->u.v.nApplyCount--; } } else { if (Z_REFCOUNTED_P(src_entry)) { @@ -2377,24 +2389,24 @@ PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC dest_zval = dest_entry; ZVAL_DEREF(dest_zval); - if (Z_ARRVAL_P(dest_zval)->nApplyCount > 1 || - Z_ARRVAL_P(src_zval)->nApplyCount > 1 || + if (Z_ARRVAL_P(dest_zval)->u.v.nApplyCount > 1 || + Z_ARRVAL_P(src_zval)->u.v.nApplyCount > 1 || (Z_ISREF_P(src_entry) && Z_ISREF_P(dest_entry) && Z_REF_P(src_entry) == Z_REF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); return 0; } SEPARATE_ZVAL(dest_zval); - Z_ARRVAL_P(dest_zval)->nApplyCount++; - Z_ARRVAL_P(src_zval)->nApplyCount++; + Z_ARRVAL_P(dest_zval)->u.v.nApplyCount++; + Z_ARRVAL_P(src_zval)->u.v.nApplyCount++; if (!php_array_replace_recursive(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval) TSRMLS_CC)) { - Z_ARRVAL_P(dest_zval)->nApplyCount--; - Z_ARRVAL_P(src_zval)->nApplyCount--; + Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--; + Z_ARRVAL_P(src_zval)->u.v.nApplyCount--; return 0; } - Z_ARRVAL_P(dest_zval)->nApplyCount--; - Z_ARRVAL_P(src_zval)->nApplyCount--; + Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--; + Z_ARRVAL_P(src_zval)->u.v.nApplyCount--; } ZEND_HASH_FOREACH_END(); return 1; @@ -2883,7 +2895,7 @@ PHP_FUNCTION(array_unique) } /* create and sort array with pointers to the target_hash buckets */ - arTmp = (struct bucketindex *) pemalloc((Z_ARRVAL_P(array)->nNumOfElements + 1) * sizeof(struct bucketindex), Z_ARRVAL_P(array)->flags & HASH_FLAG_PERSISTENT); + arTmp = (struct bucketindex *) pemalloc((Z_ARRVAL_P(array)->nNumOfElements + 1) * sizeof(struct bucketindex), Z_ARRVAL_P(array)->u.flags & HASH_FLAG_PERSISTENT); if (!arTmp) { zval_dtor(return_value); RETURN_FALSE; @@ -2922,7 +2934,7 @@ PHP_FUNCTION(array_unique) } } } - pefree(arTmp, Z_ARRVAL_P(array)->flags & HASH_FLAG_PERSISTENT); + pefree(arTmp, Z_ARRVAL_P(array)->u.flags & HASH_FLAG_PERSISTENT); } /* }}} */ @@ -3215,7 +3227,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int goto out; } hash = Z_ARRVAL(args[i]); - list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->flags & HASH_FLAG_PERSISTENT); + list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->u.flags & HASH_FLAG_PERSISTENT); if (!list) { PHP_ARRAY_CMP_FUNC_RESTORE(); @@ -3352,7 +3364,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int out: for (i = 0; i < arr_argc; i++) { hash = Z_ARRVAL(args[i]); - pefree(lists[i], hash->flags & HASH_FLAG_PERSISTENT); + pefree(lists[i], hash->u.flags & HASH_FLAG_PERSISTENT); } PHP_ARRAY_CMP_FUNC_RESTORE(); @@ -3635,7 +3647,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_ goto out; } hash = Z_ARRVAL(args[i]); - list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->flags & HASH_FLAG_PERSISTENT); + list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->u.flags & HASH_FLAG_PERSISTENT); if (!list) { PHP_ARRAY_CMP_FUNC_RESTORE(); @@ -3768,7 +3780,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_ out: for (i = 0; i < arr_argc; i++) { hash = Z_ARRVAL(args[i]); - pefree(lists[i], hash->flags & HASH_FLAG_PERSISTENT); + pefree(lists[i], hash->u.flags & HASH_FLAG_PERSISTENT); } PHP_ARRAY_CMP_FUNC_RESTORE(); @@ -4033,7 +4045,7 @@ PHP_FUNCTION(array_multisort) } hash->nNextFreeElement = array_size; - if (!(hash->flags & HASH_FLAG_PACKED)) { + if (!(hash->u.flags & HASH_FLAG_PACKED)) { zend_hash_to_packed(hash); } } diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index bf9a5a94db..7647781e2b 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -3760,9 +3760,7 @@ PHP_RINIT_FUNCTION(basic) /* {{{ */ BG(page_inode) = -1; BG(page_mtime) = -1; #ifdef HAVE_PUTENV - if (zend_hash_init(&BG(putenv_ht), 1, NULL, php_putenv_destructor, 0) == FAILURE) { - return FAILURE; - } + zend_hash_init(&BG(putenv_ht), 1, NULL, php_putenv_destructor, 0); #endif BG(user_shutdown_function_names) = NULL; diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c index ef49ee4d10..186c30cc90 100644 --- a/ext/standard/browscap.c +++ b/ext/standard/browscap.c @@ -139,7 +139,7 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_type, void *arg TSRMLS_DC) /* {{{ */ { browser_data *bdata = arg; - int persistent = bdata->htab->flags & HASH_FLAG_PERSISTENT; + int persistent = bdata->htab->u.flags & HASH_FLAG_PERSISTENT; if (!arg1) { return; @@ -232,14 +232,10 @@ static int browscap_read_file(char *filename, browser_data *browdata, int persis return FAILURE; } - if (zend_hash_init_ex(browdata->htab, 0, NULL, + zend_hash_init_ex(browdata->htab, 0, NULL, (dtor_func_t) (persistent?browscap_entry_dtor_persistent :browscap_entry_dtor_request), - persistent, 0) == FAILURE) { - pefree(browdata->htab, persistent); - browdata->htab = NULL; - return FAILURE; - } + persistent, 0); fh.handle.fp = VCWD_FOPEN(filename, "r"); fh.opened_path = NULL; diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c index 622fbfbb3f..2942daaad3 100644 --- a/ext/standard/formatted_print.c +++ b/ext/standard/formatted_print.c @@ -559,24 +559,14 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) switch (format[inpos]) { case 's': { - zval *var, var_copy; - int use_copy; - - zend_make_printable_zval(&tmp, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; - } else { - var = &tmp; - } + zend_string *str = zval_get_string(&tmp); php_sprintf_appendstring(&result, &outpos, - Z_STRVAL_P(var), + str->val, width, precision, padding, alignment, - Z_STRLEN_P(var), + str->len, 0, expprec, 0); - if (use_copy) { - zval_dtor(&var_copy); - } + STR_RELEASE(str); break; } diff --git a/ext/standard/http.c b/ext/standard/http.c index b839a4cb97..14d73779a4 100644 --- a/ext/standard/http.c +++ b/ext/standard/http.c @@ -41,7 +41,7 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, return FAILURE; } - if (ht->nApplyCount > 0) { + if (ht->u.v.nApplyCount > 0) { /* Prevent recursion */ return SUCCESS; } @@ -134,9 +134,9 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, *(p++) = 'B'; *p = '\0'; } - ht->nApplyCount++; + ht->u.v.nApplyCount++; php_url_encode_hash_ex(HASH_OF(zdata), formstr, NULL, 0, newprefix, newprefix_len, "%5D", 3, (Z_TYPE_P(zdata) == IS_OBJECT ? zdata : NULL), arg_sep, enc_type TSRMLS_CC); - ht->nApplyCount--; + ht->u.v.nApplyCount--; efree(newprefix); } else if (Z_TYPE_P(zdata) == IS_NULL || Z_TYPE_P(zdata) == IS_RESOURCE) { /* Skip these types */ diff --git a/ext/standard/php_var.h b/ext/standard/php_var.h index 4ecdd09dd7..2dc13f4012 100644 --- a/ext/standard/php_var.h +++ b/ext/standard/php_var.h @@ -59,7 +59,7 @@ do { \ /* fprintf(stderr, "SERIALIZE_INIT == lock: %u, level: %u\n", BG(serialize_lock), BG(serialize).level); */ \ if (BG(serialize_lock) || !BG(serialize).level) { \ ALLOC_HASHTABLE(var_hash_ptr); \ - zend_hash_init((var_hash_ptr), 10, NULL, NULL, 0); \ + zend_hash_init((var_hash_ptr), 16, NULL, NULL, 0); \ if (!BG(serialize_lock)) { \ BG(serialize).var_hash = (void *)(var_hash_ptr); \ BG(serialize).level = 1; \ diff --git a/ext/standard/string.c b/ext/standard/string.c index a1ea1cbf45..a960cd1a5c 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -2273,7 +2273,7 @@ PHP_FUNCTION(substr_replace) int argc = ZEND_NUM_ARGS(); zend_string *result; - HashPosition pos_str, pos_from, pos_repl, pos_len; + HashPosition pos_from, pos_repl, pos_len; zval *tmp_str = NULL, *tmp_from = NULL, *tmp_repl = NULL, *tmp_len= NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &str, &repl, &from, &len) == FAILURE) { @@ -2399,8 +2399,7 @@ PHP_FUNCTION(substr_replace) zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl); } - zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(str), &pos_str); - while ((tmp_str = zend_hash_get_current_data_ex(Z_ARRVAL_P(str), &pos_str)) != NULL) { + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(str), num_index, str_index, tmp_str) { zval *orig_str; zval dummy; @@ -2542,8 +2541,11 @@ PHP_FUNCTION(substr_replace) result->val[result->len] = '\0'; - if (zend_hash_get_current_key_ex(Z_ARRVAL_P(str), &str_index, &num_index, 0, &pos_str) == HASH_KEY_IS_STRING) { - add_assoc_str_ex(return_value, str_index->val, str_index->len, result); + if (str_index) { + zval tmp; + + ZVAL_STR(&tmp, result); + zend_symtable_update(Z_ARRVAL_P(return_value), str_index, &tmp); } else { add_index_str(return_value, num_index, result); } @@ -2553,8 +2555,7 @@ PHP_FUNCTION(substr_replace) } else { //??? Z_SET_ISREF_TO_P(orig_str, was_ref); } - zend_hash_move_forward_ex(Z_ARRVAL_P(str), &pos_str); - } /*while*/ + } ZEND_HASH_FOREACH_END(); } /* if */ } /* }}} */ @@ -3932,30 +3933,22 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit /* if subject is an array */ if (Z_TYPE_P(subject) == IS_ARRAY) { array_init(return_value); - zend_hash_internal_pointer_reset(Z_ARRVAL_P(subject)); /* For each subject entry, convert it to string, then perform replacement and add the result to the return_value array. */ - while ((subject_entry = zend_hash_get_current_data(Z_ARRVAL_P(subject))) != NULL) { + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(subject), num_key, string_key, subject_entry) { if (Z_TYPE_P(subject_entry) != IS_ARRAY && Z_TYPE_P(subject_entry) != IS_OBJECT) { php_str_replace_in_subject(search, replace, subject_entry, &result, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC); } else { ZVAL_COPY(&result, subject_entry); } /* Add to return array */ - switch (zend_hash_get_current_key(Z_ARRVAL_P(subject), &string_key, - &num_key, 0)) { - case HASH_KEY_IS_STRING: - zend_hash_update(Z_ARRVAL_P(return_value), string_key, &result); - break; - - case HASH_KEY_IS_LONG: - add_index_zval(return_value, num_key, &result); - break; + if (string_key) { + zend_hash_update(Z_ARRVAL_P(return_value), string_key, &result); + } else { + add_index_zval(return_value, num_key, &result); } - - zend_hash_move_forward(Z_ARRVAL_P(subject)); - } + } ZEND_HASH_FOREACH_END(); } else { /* if subject is not an array */ php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC); } @@ -4963,31 +4956,13 @@ static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case) PHPAPI int string_natural_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - int use_copy1 = 0, use_copy2 = 0; + zend_string *str1 = zval_get_string(op1); + zend_string *str2 = zval_get_string(op2); - if (Z_TYPE_P(op1) != IS_STRING) { - zend_make_printable_zval(op1, &op1_copy, &use_copy1); - } - if (Z_TYPE_P(op2) != IS_STRING) { - zend_make_printable_zval(op2, &op2_copy, &use_copy2); - } - - if (use_copy1) { - op1 = &op1_copy; - } - if (use_copy2) { - op2 = &op2_copy; - } - - ZVAL_LONG(result, strnatcmp_ex(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2), case_insensitive)); + ZVAL_LONG(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); - if (use_copy1) { - zval_dtor(op1); - } - if (use_copy2) { - zval_dtor(op2); - } + STR_RELEASE(str1); + STR_RELEASE(str2); return SUCCESS; } /* }}} */ diff --git a/ext/standard/type.c b/ext/standard/type.c index c4fdbc87e3..1e3572c22f 100644 --- a/ext/standard/type.c +++ b/ext/standard/type.c @@ -195,21 +195,12 @@ PHP_FUNCTION(boolval) Get the string value of a variable */ PHP_FUNCTION(strval) { - zval *num, *tmp; - zval expr_copy; - int use_copy; - + zval *num; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &num) == FAILURE) { return; } - zend_make_printable_zval(num, &expr_copy, &use_copy); - if (use_copy) { - tmp = &expr_copy; - RETVAL_ZVAL(tmp, 0, 0); - } else { - RETVAL_ZVAL(num, 1, 0); - } + RETVAL_STR(zval_get_string(num)); } /* }}} */ diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c index 762b65387a..b0811d8c4f 100644 --- a/ext/standard/user_filters.c +++ b/ext/standard/user_filters.c @@ -578,7 +578,7 @@ PHP_FUNCTION(stream_filter_register) if (!BG(user_filter_map)) { BG(user_filter_map) = (HashTable*) emalloc(sizeof(HashTable)); - zend_hash_init(BG(user_filter_map), 5, NULL, (dtor_func_t) filter_item_dtor, 0); + zend_hash_init(BG(user_filter_map), 8, NULL, (dtor_func_t) filter_item_dtor, 0); } fdat = ecalloc(1, sizeof(struct php_user_filter_data)); diff --git a/ext/standard/var.c b/ext/standard/var.c index a4e556abdc..3dbd71abd5 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -148,9 +148,9 @@ again: break; case IS_ARRAY: myht = Z_ARRVAL_P(struc); - if (++myht->nApplyCount > 1) { + if (++myht->u.v.nApplyCount > 1) { PUTS("*RECURSION*\n"); - --myht->nApplyCount; + --myht->u.v.nApplyCount; return; } php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht)); @@ -159,9 +159,9 @@ again: goto head_done; case IS_OBJECT: myht = Z_OBJDEBUG_P(struc, is_temp); - if (myht && ++myht->nApplyCount > 1) { + if (myht && ++myht->u.v.nApplyCount > 1) { PUTS("*RECURSION*\n"); - --myht->nApplyCount; + --myht->u.v.nApplyCount; return; } @@ -176,7 +176,7 @@ again: head_done: if (myht) { zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level); - --myht->nApplyCount; + --myht->u.v.nApplyCount; if (is_temp) { zend_hash_destroy(myht); efree(myht); @@ -323,7 +323,7 @@ again: break; case IS_ARRAY: myht = Z_ARRVAL_P(struc); - if (myht->nApplyCount > 1) { + if (myht->u.v.nApplyCount > 1) { PUTS("*RECURSION*\n"); return; } @@ -332,7 +332,7 @@ again: goto head_done; case IS_OBJECT: myht = Z_OBJDEBUG_P(struc, is_temp); - if (myht && myht->nApplyCount > 1) { + if (myht && myht->u.v.nApplyCount > 1) { PUTS("*RECURSION*\n"); return; } @@ -522,7 +522,7 @@ again: break; case IS_ARRAY: myht = Z_ARRVAL_P(struc); - if (myht->nApplyCount > 0){ + if (myht->u.v.nApplyCount > 0){ smart_str_appendl(buf, "NULL", 4); zend_error(E_WARNING, "var_export does not handle circular references"); return; @@ -543,7 +543,7 @@ again: case IS_OBJECT: myht = Z_OBJPROP_P(struc); - if(myht && myht->nApplyCount > 0){ + if(myht && myht->u.v.nApplyCount > 0){ smart_str_appendl(buf, "NULL", 4); zend_error(E_WARNING, "var_export does not handle circular references"); return; @@ -961,16 +961,16 @@ again: /* we should still add element even if it's not OK, * since we already wrote the length of the array before */ if ((Z_TYPE_P(data) == IS_ARRAY && Z_TYPE_P(struc) == IS_ARRAY && Z_ARR_P(data) == Z_ARR_P(struc)) - || (Z_TYPE_P(data) == IS_ARRAY && Z_ARRVAL_P(data)->nApplyCount > 1) + || (Z_TYPE_P(data) == IS_ARRAY && Z_ARRVAL_P(data)->u.v.nApplyCount > 1) ) { smart_str_appendl(buf, "N;", 2); } else { if (Z_TYPE_P(data) == IS_ARRAY) { - Z_ARRVAL_P(data)->nApplyCount++; + Z_ARRVAL_P(data)->u.v.nApplyCount++; } php_var_serialize_intern(buf, data, var_hash TSRMLS_CC); if (Z_TYPE_P(data) == IS_ARRAY) { - Z_ARRVAL_P(data)->nApplyCount--; + Z_ARRVAL_P(data)->u.v.nApplyCount--; } } } ZEND_HASH_FOREACH_END(); diff --git a/main/SAPI.c b/main/SAPI.c index 2b8b1826da..9cacbd4b4b 100644 --- a/main/SAPI.c +++ b/main/SAPI.c @@ -65,7 +65,7 @@ static void _type_dtor(zval *zv) static void sapi_globals_ctor(sapi_globals_struct *sapi_globals TSRMLS_DC) { memset(sapi_globals, 0, sizeof(*sapi_globals)); - zend_hash_init_ex(&sapi_globals->known_post_content_types, 5, NULL, _type_dtor, 1, 0); + zend_hash_init_ex(&sapi_globals->known_post_content_types, 8, NULL, _type_dtor, 1, 0); php_setup_sapi_content_types(TSRMLS_C); } diff --git a/main/output.c b/main/output.c index 13cea0a8f8..cbf1fed9f0 100644 --- a/main/output.c +++ b/main/output.c @@ -137,9 +137,9 @@ static void reverse_conflict_dtor(zval *zv) PHPAPI void php_output_startup(void) { ZEND_INIT_MODULE_GLOBALS(output, php_output_init_globals, NULL); - zend_hash_init(&php_output_handler_aliases, 0, NULL, NULL, 1); - zend_hash_init(&php_output_handler_conflicts, 0, NULL, NULL, 1); - zend_hash_init(&php_output_handler_reverse_conflicts, 0, NULL, reverse_conflict_dtor, 1); + zend_hash_init(&php_output_handler_aliases, 8, NULL, NULL, 1); + zend_hash_init(&php_output_handler_conflicts, 8, NULL, NULL, 1); + zend_hash_init(&php_output_handler_reverse_conflicts, 8, NULL, reverse_conflict_dtor, 1); php_output_direct = php_output_stdout; } /* }}} */ @@ -636,7 +636,7 @@ PHPAPI int php_output_handler_reverse_conflict_register(const char *name, size_t if (SUCCESS == (rev_ptr = zend_hash_str_find_ptr(&php_output_handler_reverse_conflicts, name, name_len))) { return zend_hash_next_index_insert_ptr(rev_ptr, check_func) ? SUCCESS : FAILURE; } else { - zend_hash_init(&rev, 1, NULL, NULL, 1); + zend_hash_init(&rev, 8, NULL, NULL, 1); if (SUCCESS != zend_hash_next_index_insert_ptr(&rev, check_func)) { zend_hash_destroy(&rev); return FAILURE; diff --git a/main/php_ini.c b/main/php_ini.c index 024dbe6821..ed7da808f7 100644 --- a/main/php_ini.c +++ b/main/php_ini.c @@ -262,7 +262,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t /* If option not found in hash or is not an array -> create array, otherwise add to existing array */ if ((find_arr = zend_hash_find(active_hash, Z_STR_P(arg1))) == NULL || Z_TYPE_P(find_arr) != IS_ARRAY) { ZVAL_NEW_PERSISTENT_ARR(&option_arr); - zend_hash_init(Z_ARRVAL(option_arr), 0, NULL, (dtor_func_t) config_zval_dtor, 1); + zend_hash_init(Z_ARRVAL(option_arr), 8, NULL, (dtor_func_t) config_zval_dtor, 1); find_arr = zend_hash_update(active_hash, Z_STR_P(arg1), &option_arr); } @@ -329,7 +329,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t zval section_arr; ZVAL_NEW_PERSISTENT_ARR(§ion_arr); - zend_hash_init(Z_ARRVAL(section_arr), 0, NULL, (dtor_func_t) config_zval_dtor, 1); + zend_hash_init(Z_ARRVAL(section_arr), 8, NULL, (dtor_func_t) config_zval_dtor, 1); entry = zend_hash_str_update(target_hash, key, key_len, §ion_arr); } active_ini_hash = Z_ARRVAL_P(entry); @@ -385,9 +385,7 @@ int php_init_config(TSRMLS_D) int free_ini_search_path = 0; zend_file_handle fh; - if (zend_hash_init(&configuration_hash, 0, NULL, (dtor_func_t) config_zval_dtor, 1) == FAILURE) { - return FAILURE; - } + zend_hash_init(&configuration_hash, 8, NULL, (dtor_func_t) config_zval_dtor, 1); if (sapi_module.ini_defaults) { sapi_module.ini_defaults(&configuration_hash); diff --git a/main/rfc1867.c b/main/rfc1867.c index 5acebd5b5b..98a29f1e39 100644 --- a/main/rfc1867.c +++ b/main/rfc1867.c @@ -762,10 +762,10 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ } /* Initialize $_FILES[] */ - zend_hash_init(&PG(rfc1867_protected_variables), 5, NULL, NULL, 0); + zend_hash_init(&PG(rfc1867_protected_variables), 8, NULL, NULL, 0); ALLOC_HASHTABLE(uploaded_files); - zend_hash_init(uploaded_files, 5, NULL, free_filename, 0); + zend_hash_init(uploaded_files, 8, NULL, free_filename, 0); SG(rfc1867_uploaded_files) = uploaded_files; array_init(&PG(http_globals)[TRACK_VARS_FILES]); diff --git a/main/streams/streams.c b/main/streams/streams.c index 553404dc3c..7ab74c7c08 100644 --- a/main/streams/streams.c +++ b/main/streams/streams.c @@ -1648,14 +1648,11 @@ int php_init_stream_wrappers(int module_number TSRMLS_DC) /* Filters are cleaned up by the streams they're attached to */ le_stream_filter = zend_register_list_destructors_ex(NULL, NULL, "stream filter", module_number); - return ( - zend_hash_init(&url_stream_wrappers_hash, 0, NULL, NULL, 1) == SUCCESS - && - zend_hash_init(php_get_stream_filters_hash_global(), 0, NULL, NULL, 1) == SUCCESS - && - zend_hash_init(php_stream_xport_get_hash(), 0, NULL, NULL, 1) == SUCCESS - && - php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS + zend_hash_init(&url_stream_wrappers_hash, 8, NULL, NULL, 1); + zend_hash_init(php_get_stream_filters_hash_global(), 8, NULL, NULL, 1); + zend_hash_init(php_stream_xport_get_hash(), 8, NULL, NULL, 1); + + return (php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS && php_stream_xport_register("udp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS #if defined(AF_UNIX) && !(defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE)) diff --git a/sapi/cgi/cgi_main.c b/sapi/cgi/cgi_main.c index 6384c66bca..f3e9dd6f0f 100644 --- a/sapi/cgi/cgi_main.c +++ b/sapi/cgi/cgi_main.c @@ -234,7 +234,7 @@ static void print_modules(TSRMLS_D) { HashTable sorted_registry; - zend_hash_init(&sorted_registry, 50, NULL, NULL, 1); + zend_hash_init(&sorted_registry, 64, NULL, NULL, 1); //??? zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry)); zend_hash_copy(&sorted_registry, &module_registry, NULL); zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC); @@ -756,7 +756,7 @@ static void php_cgi_ini_activate_user_config(char *path, int path_len, const cha new_entry = pemalloc(sizeof(user_config_cache_entry), 1); new_entry->expires = 0; new_entry->user_config = (HashTable *) pemalloc(sizeof(HashTable), 1); - zend_hash_init(new_entry->user_config, 0, NULL, (dtor_func_t) config_zval_dtor, 1); + zend_hash_init(new_entry->user_config, 8, NULL, (dtor_func_t) config_zval_dtor, 1); entry = zend_hash_str_update_ptr(&CGIG(user_config_cache), path, path_len, new_entry); } @@ -1475,7 +1475,7 @@ static void php_cgi_globals_ctor(php_cgi_globals_struct *php_cgi_globals TSRMLS_ #ifdef PHP_WIN32 php_cgi_globals->impersonate = 0; #endif - zend_hash_init(&php_cgi_globals->user_config_cache, 0, NULL, (dtor_func_t) user_config_cache_entry_dtor, 1); + zend_hash_init(&php_cgi_globals->user_config_cache, 8, NULL, (dtor_func_t) user_config_cache_entry_dtor, 1); } /* }}} */ diff --git a/sapi/cgi/fastcgi.c b/sapi/cgi/fastcgi.c index a5845d9f8d..585b6b8e87 100644 --- a/sapi/cgi/fastcgi.c +++ b/sapi/cgi/fastcgi.c @@ -411,7 +411,7 @@ int fcgi_init(void) sa_t sa; socklen_t len = sizeof(sa); #endif - zend_hash_init(&fcgi_mgmt_vars, 0, NULL, fcgi_free_mgmt_var_cb, 1); + zend_hash_init(&fcgi_mgmt_vars, 8, NULL, fcgi_free_mgmt_var_cb, 1); fcgi_set_mgmt_var("FCGI_MPXS_CONNS", sizeof("FCGI_MPXS_CONNS")-1, "0", sizeof("0")-1); is_initialized = 1; diff --git a/sapi/phpdbg/phpdbg_info.c b/sapi/phpdbg/phpdbg_info.c index f7c7ab0846..5596255d6e 100644 --- a/sapi/phpdbg/phpdbg_info.c +++ b/sapi/phpdbg/phpdbg_info.c @@ -215,7 +215,7 @@ PHPDBG_INFO(literal) /* {{{ */ if (Z_TYPE(ops->literals[literal]) != IS_NULL) { phpdbg_write("|-------- C%u -------> [", literal); zend_print_zval( - &ops->literals[literal], 0); + &ops->literals[literal], 0 TSRMLS_CC); phpdbg_write("]"); phpdbg_writeln(EMPTY); } |