From 3e9bb03a62393d7bad1a0261b7a312c2ced8aac0 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Mon, 28 Nov 2016 22:59:57 +0300 Subject: [PATCH] Removed IS_TYPE_IMMUTABLE (it's the same as COPYABLE & !REFCOUED) --- NEWS | 1 + Zend/zend_ast.c | 2 +- Zend/zend_builtin_functions.c | 6 +++--- Zend/zend_execute_API.c | 4 ++-- Zend/zend_object_handlers.c | 2 +- Zend/zend_types.h | 35 ++++++++++++----------------------- Zend/zend_variables.h | 30 +++--------------------------- ext/mbstring/mbstring.c | 8 ++++---- ext/opcache/zend_persist.c | 15 ++++++--------- ext/wddx/wddx.c | 2 +- 10 files changed, 34 insertions(+), 71 deletions(-) diff --git a/NEWS b/NEWS index 7bacef200c..ec4e1e2b13 100644 --- a/NEWS +++ b/NEWS @@ -6,6 +6,7 @@ PHP NEWS . Fix integer overflows (Joshua Rogers) - Core: + . Removed IS_TYPE_IMMUTABLE (it's the same as COPYABLE & !REFCOUED). (Dmitry) . Removed the sql.safe_mode directive. (Kalle) . Removed support for Netware. (Kalle) . Fixed bug #54535 (WSA cleanup executes before MSHUTDOWN). (Kalle) diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index dba945129c..5072c62891 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -266,7 +266,7 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc zval *zv = zend_ast_get_zval(ast); if (Z_OPT_CONSTANT_P(zv)) { - if (!(Z_TYPE_FLAGS_P(zv) & IS_TYPE_IMMUTABLE)) { + if (Z_TYPE_FLAGS_P(zv) & IS_TYPE_REFCOUNTED) { if (UNEXPECTED(zval_update_constant_ex(zv, scope) != SUCCESS)) { ret = FAILURE; break; diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 1faf57cf31..41da1f9537 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -836,7 +836,7 @@ static int validate_constant_array(HashTable *ht) /* {{{ */ ZVAL_DEREF(val); if (Z_REFCOUNTED_P(val)) { if (Z_TYPE_P(val) == IS_ARRAY) { - if (!Z_IMMUTABLE_P(val)) { + if (Z_REFCOUNTED_P(val)) { if (Z_ARRVAL_P(val)->u.v.nApplyCount > 0) { zend_error(E_WARNING, "Constants cannot be recursive arrays"); ret = 0; @@ -874,7 +874,7 @@ static void copy_constant_array(zval *dst, zval *src) /* {{{ */ new_val = zend_hash_index_add_new(Z_ARRVAL_P(dst), idx, val); } if (Z_TYPE_P(val) == IS_ARRAY) { - if (!Z_IMMUTABLE_P(val)) { + if (Z_REFCOUNTED_P(val)) { copy_constant_array(new_val, val); } } else if (Z_REFCOUNTED_P(val)) { @@ -932,7 +932,7 @@ repeat: val = &val_free; break; case IS_ARRAY: - if (!Z_IMMUTABLE_P(val)) { + if (Z_REFCOUNTED_P(val)) { if (!validate_constant_array(Z_ARRVAL_P(val))) { RETURN_FALSE; } else { diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index cb2e936df0..c01a807e55 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -573,7 +573,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_class_entry *scope) /* {{{ */ zend_throw_error(NULL, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p)); return FAILURE; } - inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0; + inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_REFCOUNTED) != 0; SEPARATE_ZVAL_NOREF(p); MARK_CONSTANT_VISITED(p); if (Z_CONST_FLAGS_P(p) & IS_CONSTANT_CLASS) { @@ -638,7 +638,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_class_entry *scope) /* {{{ */ } else if (Z_TYPE_P(p) == IS_CONSTANT_AST) { zval tmp; - inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0; + inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_REFCOUNTED) != 0; if (UNEXPECTED(zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope) != SUCCESS)) { return FAILURE; } diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 2273b06fb3..19165d69f6 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -163,7 +163,7 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp) /* {{{ * zend_call_method_with_0_params(object, ce, &ce->__debugInfo, ZEND_DEBUGINFO_FUNC_NAME, &retval); if (Z_TYPE(retval) == IS_ARRAY) { - if (Z_IMMUTABLE(retval)) { + if (!Z_REFCOUNTED(retval)) { *is_temp = 1; return zend_array_dup(Z_ARRVAL(retval)); } else if (Z_REFCOUNT(retval) <= 1) { diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 9d4f6a7d4c..16619f04b4 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -386,7 +386,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define Z_GC_INFO(zval) GC_INFO(Z_COUNTED(zval)) #define Z_GC_INFO_P(zval_p) Z_GC_INFO(*(zval_p)) - #define Z_GC_TYPE_INFO(zval) GC_TYPE_INFO(Z_COUNTED(zval)) #define Z_GC_TYPE_INFO_P(zval_p) Z_GC_TYPE_INFO(*(zval_p)) @@ -402,7 +401,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { /* zval.u1.v.type_flags */ #define IS_TYPE_CONSTANT (1<<0) -#define IS_TYPE_IMMUTABLE (1<<1) #define IS_TYPE_REFCOUNTED (1<<2) #define IS_TYPE_COPYABLE (1<<4) @@ -437,7 +435,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define IS_STR_CONSTANT_UNQUALIFIED (1<<4) /* the same as IS_CONSTANT_UNQUALIFIED */ /* array flags */ -#define IS_ARRAY_IMMUTABLE (1<<1) /* the same as IS_TYPE_IMMUTABLE */ +#define IS_ARRAY_IMMUTABLE (1<<1) /* object flags (zval.value->gc.u.flags) */ #define IS_OBJ_APPLY_COUNT 0x07 @@ -475,9 +473,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define Z_COPYABLE(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_COPYABLE) != 0) #define Z_COPYABLE_P(zval_p) Z_COPYABLE(*(zval_p)) -#define Z_IMMUTABLE(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_IMMUTABLE) != 0) -#define Z_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p)) - /* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */ #define Z_OPT_TYPE(zval) (Z_TYPE_INFO(zval) & Z_TYPE_MASK) #define Z_OPT_TYPE_P(zval_p) Z_OPT_TYPE(*(zval_p)) @@ -491,9 +486,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define Z_OPT_COPYABLE(zval) ((Z_TYPE_INFO(zval) & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0) #define Z_OPT_COPYABLE_P(zval_p) Z_OPT_COPYABLE(*(zval_p)) -#define Z_OPT_IMMUTABLE(zval) ((Z_TYPE_INFO(zval) & (IS_TYPE_IMMUTABLE << Z_TYPE_FLAGS_SHIFT)) != 0) -#define Z_OPT_IMMUTABLE_P(zval_p) Z_OPT_IMMUTABLE(*(zval_p)) - #define Z_OPT_ISREF(zval) (Z_OPT_TYPE(zval) == IS_REFERENCE) #define Z_OPT_ISREF_P(zval_p) Z_OPT_ISREF(*(zval_p)) @@ -818,7 +810,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define Z_TRY_DELREF(z) Z_TRY_DELREF_P(&(z)) static zend_always_inline uint32_t zval_refcount_p(zval* pz) { - ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_IMMUTABLE_P(pz)); + ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_COPYABLE_P(pz)); return GC_REFCOUNT(Z_COUNTED_P(pz)); } @@ -883,8 +875,8 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { zend_refcounted *_gc = Z_COUNTED_P(_z2); \ uint32_t _t = Z_TYPE_INFO_P(_z2); \ ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \ - if ((_t & ((IS_TYPE_REFCOUNTED|IS_TYPE_IMMUTABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \ - if ((_t & ((IS_TYPE_COPYABLE|IS_TYPE_IMMUTABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \ + if ((_t & ((IS_TYPE_REFCOUNTED|IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \ + if ((_t & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0) { \ _zval_copy_ctor_func(_z1 ZEND_FILE_LINE_CC); \ } else { \ GC_REFCOUNT(_gc)++; \ @@ -950,7 +942,7 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { zval *_zv = (zv); \ zend_array *_arr = Z_ARR_P(_zv); \ if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) { \ - if (!Z_IMMUTABLE_P(_zv)) { \ + if (Z_REFCOUNTED_P(_zv)) { \ GC_REFCOUNT(_arr)--; \ } \ ZVAL_ARR(_zv, zend_array_dup(_arr)); \ @@ -960,10 +952,9 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { #define SEPARATE_ZVAL_NOREF(zv) do { \ zval *_zv = (zv); \ ZEND_ASSERT(Z_TYPE_P(_zv) != IS_REFERENCE); \ - if (Z_COPYABLE_P(_zv) || \ - Z_IMMUTABLE_P(_zv)) { \ + if (Z_COPYABLE_P(_zv)) { \ if (Z_REFCOUNT_P(_zv) > 1) { \ - if (!Z_IMMUTABLE_P(_zv)) { \ + if (Z_REFCOUNTED_P(_zv)) { \ Z_DELREF_P(_zv); \ } \ zval_copy_ctor_func(_zv); \ @@ -974,11 +965,10 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { #define SEPARATE_ZVAL(zv) do { \ zval *_zv = (zv); \ if (Z_REFCOUNTED_P(_zv) || \ - Z_IMMUTABLE_P(_zv)) { \ + Z_COPYABLE_P(_zv)) { \ if (Z_REFCOUNT_P(_zv) > 1) { \ - if (Z_COPYABLE_P(_zv) || \ - Z_IMMUTABLE_P(_zv)) { \ - if (!Z_IMMUTABLE_P(_zv)) { \ + if (Z_COPYABLE_P(_zv)) { \ + if (Z_REFCOUNTED_P(_zv)) { \ Z_DELREF_P(_zv); \ } \ zval_copy_ctor_func(_zv); \ @@ -992,10 +982,9 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { #define SEPARATE_ZVAL_IF_NOT_REF(zv) do { \ zval *_zv = (zv); \ - if (Z_COPYABLE_P(_zv) || \ - Z_IMMUTABLE_P(_zv)) { \ + if (Z_COPYABLE_P(_zv)) { \ if (Z_REFCOUNT_P(_zv) > 1) { \ - if (!Z_IMMUTABLE_P(_zv)) { \ + if (Z_REFCOUNTED_P(_zv)) { \ Z_DELREF_P(_zv); \ } \ zval_copy_ctor_func(_zv); \ diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h index b0054eedd3..f039986c6e 100644 --- a/Zend/zend_variables.h +++ b/Zend/zend_variables.h @@ -55,29 +55,7 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC) { - if (Z_REFCOUNTED_P(zvalue) || Z_IMMUTABLE_P(zvalue)) { - if (Z_COPYABLE_P(zvalue) || Z_IMMUTABLE_P(zvalue)) { - _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC); - } else { - Z_ADDREF_P(zvalue); - } - } -} - -static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC) -{ - if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) { - if (Z_OPT_COPYABLE_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) { - _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC); - } else { - Z_ADDREF_P(zvalue); - } - } -} - -static zend_always_inline void _zval_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC) -{ - if (Z_REFCOUNTED_P(zvalue)) { + if (Z_REFCOUNTED_P(zvalue) || Z_COPYABLE_P(zvalue)) { if (Z_COPYABLE_P(zvalue)) { _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC); } else { @@ -86,9 +64,9 @@ static zend_always_inline void _zval_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LIN } } -static zend_always_inline void _zval_opt_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC) +static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC) { - if (Z_OPT_REFCOUNTED_P(zvalue)) { + if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_COPYABLE_P(zvalue)) { if (Z_OPT_COPYABLE_P(zvalue)) { _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC); } else { @@ -105,8 +83,6 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC); ZEND_API void _zval_dtor_wrapper(zval *zvalue); #define zval_copy_ctor(zvalue) _zval_copy_ctor((zvalue) ZEND_FILE_LINE_CC) #define zval_opt_copy_ctor(zvalue) _zval_opt_copy_ctor((zvalue) ZEND_FILE_LINE_CC) -#define zval_copy_ctor_no_imm(zvalue) _zval_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC) -#define zval_opt_copy_ctor_no_imm(zvalue) _zval_opt_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC) #define zval_dtor(zvalue) zval_ptr_dtor_nogc(zvalue) #define zval_ptr_dtor(zval_ptr) _zval_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC) #define zval_ptr_dtor_nogc(zval_ptr) _zval_ptr_dtor_nogc((zval_ptr) ZEND_FILE_LINE_CC) diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c index 8db82aa83a..a81c6149ee 100644 --- a/ext/mbstring/mbstring.c +++ b/ext/mbstring/mbstring.c @@ -3939,7 +3939,7 @@ PHP_FUNCTION(mb_convert_variables) target_hash = HASH_OF(var); if (target_hash != NULL) { while ((hash_entry = zend_hash_get_current_data(target_hash)) != NULL) { - if (!Z_IMMUTABLE_P(var)) { + if (Z_REFCOUNTED_P(var)) { if (++target_hash->u.v.nApplyCount > 1) { --target_hash->u.v.nApplyCount; recursion_error = 1; @@ -3988,7 +3988,7 @@ detect_end: } if (recursion_error) { while(stack_level-- && (var = &stack[stack_level])) { - if (!Z_IMMUTABLE_P(var)) { + if (Z_REFCOUNTED_P(var)) { if (HASH_OF(var)->u.v.nApplyCount > 1) { HASH_OF(var)->u.v.nApplyCount--; } @@ -4055,7 +4055,7 @@ detect_end: hash_entry = hash_entry_ptr; ZVAL_DEREF(hash_entry); if (Z_TYPE_P(hash_entry) == IS_ARRAY || Z_TYPE_P(hash_entry) == IS_OBJECT) { - if (!Z_IMMUTABLE_P(hash_entry)) { + if (Z_REFCOUNTED_P(hash_entry)) { if (++(HASH_OF(hash_entry)->u.v.nApplyCount) > 1) { --(HASH_OF(hash_entry)->u.v.nApplyCount); recursion_error = 1; @@ -4108,7 +4108,7 @@ conv_end: if (recursion_error) { while(stack_level-- && (var = &stack[stack_level])) { - if (!Z_IMMUTABLE_P(var)) { + if (Z_REFCOUNTED_P(var)) { if (HASH_OF(var)->u.v.nApplyCount > 1) { HASH_OF(var)->u.v.nApplyCount--; } diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index e022b40950..3956a71610 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -276,18 +276,15 @@ static void zend_persist_zval(zval *z) flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT); zend_accel_store_interned_string(Z_STR_P(z)); Z_GC_FLAGS_P(z) |= flags; - Z_TYPE_FLAGS_P(z) &= ~(IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); - if (Z_TYPE_P(z) == IS_CONSTANT) { - Z_TYPE_FLAGS_P(z) |= IS_TYPE_IMMUTABLE; - } + Z_TYPE_FLAGS_P(z) &= ~IS_TYPE_REFCOUNTED; break; case IS_ARRAY: new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z)); if (new_ptr) { Z_ARR_P(z) = new_ptr; - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; + Z_TYPE_FLAGS_P(z) = IS_TYPE_COPYABLE; } else { - if (Z_IMMUTABLE_P(z)) { + if (!Z_REFCOUNTED_P(z)) { Z_ARR_P(z) = zend_accel_memdup(Z_ARR_P(z), sizeof(zend_array)); zend_hash_persist_immutable(Z_ARRVAL_P(z)); } else { @@ -295,7 +292,7 @@ static void zend_persist_zval(zval *z) zend_accel_store(Z_ARR_P(z), sizeof(zend_array)); zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval); /* make immutable array */ - Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE; + Z_TYPE_FLAGS_P(z) = IS_TYPE_COPYABLE; GC_REFCOUNT(Z_COUNTED_P(z)) = 2; GC_FLAGS(Z_COUNTED_P(z)) |= IS_ARRAY_IMMUTABLE; Z_ARRVAL_P(z)->u.flags |= HASH_FLAG_STATIC_KEYS; @@ -316,11 +313,11 @@ static void zend_persist_zval(zval *z) new_ptr = zend_shared_alloc_get_xlat_entry(Z_AST_P(z)); if (new_ptr) { Z_AST_P(z) = new_ptr; - Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_IMMUTABLE; + Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_COPYABLE; } else { zend_accel_store(Z_AST_P(z), sizeof(zend_ast_ref)); Z_ASTVAL_P(z) = zend_persist_ast(Z_ASTVAL_P(z)); - Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_IMMUTABLE; + Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_COPYABLE; GC_REFCOUNT(Z_COUNTED_P(z)) = 2; } break; diff --git a/ext/wddx/wddx.c b/ext/wddx/wddx.c index f3d72ddadf..6b8e621ccf 100644 --- a/ext/wddx/wddx.c +++ b/ext/wddx/wddx.c @@ -693,7 +693,7 @@ static void php_wddx_add_var(wddx_packet *packet, zval *name_var) return; } - if (Z_IMMUTABLE_P(name_var)) { + if (!Z_REFCOUNTED_P(name_var)) { ZEND_HASH_FOREACH_VAL(target_hash, val) { php_wddx_add_var(packet, val); } ZEND_HASH_FOREACH_END(); -- 2.40.0