From: Dmitry Stogov Date: Thu, 5 Oct 2017 23:54:14 +0000 (+0300) Subject: HASH_FLAG_PERSISTENT renamed into IS_ARRAY_PERSISTENT and moved into GC_FLAGS (to... X-Git-Tag: php-7.3.0alpha1~1326 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=254b74b85f0d9467c937ccee8aab02e31729d49b;p=php HASH_FLAG_PERSISTENT renamed into IS_ARRAY_PERSISTENT and moved into GC_FLAGS (to be consistent with IS_STR_PERSISTENT). --- diff --git a/UPGRADING.INTERNALS b/UPGRADING.INTERNALS index 1b6ba2adbb..d314f8316a 100644 --- a/UPGRADING.INTERNALS +++ b/UPGRADING.INTERNALS @@ -12,6 +12,7 @@ PHP 7.2 INTERNALS UPGRADE NOTES i. array_init() and array_init_size() j. Run-time constant operand addressing k. Array/Object recursion protection + l. HASH_FLAG_PERSISTENT 2. Build system changes a. Unix build system changes @@ -84,6 +85,8 @@ PHP 7.2 INTERNALS UPGRADE NOTES Corresponding checks should be replaced by Z_REFCOUNTED() or !(GC_GLAGS(p) & GC_IMMUTABLE). + l. HASH_FLAG_PERSISTENT renamed into IS_ARRAY_PERSISTENT and moved into + GC_FLAGS (to be consistent with IS_STR_PERSISTENT). ======================== 2. Build system changes diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 92f8358a00..07dcd26e8d 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -119,12 +119,12 @@ static zend_always_inline void zend_hash_real_init_ex(HashTable *ht, int packed) HT_ASSERT_RC1(ht); ZEND_ASSERT(!((ht)->u.flags & HASH_FLAG_INITIALIZED)); if (packed) { - HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), (ht)->u.flags & HASH_FLAG_PERSISTENT)); + HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT)); (ht)->u.flags |= HASH_FLAG_INITIALIZED | HASH_FLAG_PACKED; HT_HASH_RESET_PACKED(ht); } else { (ht)->nTableMask = -(ht)->nTableSize; - HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), (ht)->u.flags & HASH_FLAG_PERSISTENT)); + HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT)); (ht)->u.flags |= HASH_FLAG_INITIALIZED; if (EXPECTED(ht->nTableMask == (uint32_t)-8)) { Bucket *arData = ht->arData; @@ -160,8 +160,8 @@ static const uint32_t uninitialized_bucket[-HT_MIN_MASK] = static zend_always_inline void _zend_hash_init_int(HashTable *ht, uint32_t nSize, dtor_func_t pDestructor, zend_bool persistent) { GC_REFCOUNT(ht) = 1; - GC_TYPE_INFO(ht) = IS_ARRAY | (persistent ? 0 : (GC_COLLECTABLE << GC_FLAGS_SHIFT)); - ht->u.flags = (persistent ? HASH_FLAG_PERSISTENT : 0) | HASH_FLAG_STATIC_KEYS; + GC_TYPE_INFO(ht) = IS_ARRAY | (persistent ? (GC_PERSISTENT << GC_FLAGS_SHIFT) : (GC_COLLECTABLE << GC_FLAGS_SHIFT)); + ht->u.flags = HASH_FLAG_STATIC_KEYS; ht->nTableMask = HT_MIN_MASK; HT_SET_DATA_ADDR(ht, &uninitialized_bucket); ht->nNumUsed = 0; @@ -191,7 +191,7 @@ static void ZEND_FASTCALL zend_hash_packed_grow(HashTable *ht) zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%u * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket), sizeof(Bucket)); } ht->nTableSize += ht->nTableSize; - HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT)); + HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT)); } ZEND_API void ZEND_FASTCALL zend_hash_real_init(HashTable *ht, zend_bool packed) @@ -209,11 +209,11 @@ ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht) HT_ASSERT_RC1(ht); ht->u.flags &= ~HASH_FLAG_PACKED; - new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), (ht)->u.flags & HASH_FLAG_PERSISTENT); + new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); ht->nTableMask = -ht->nTableSize; HT_SET_DATA_ADDR(ht, new_data); memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed); - pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT); + pefree(old_data, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zend_hash_rehash(ht); } @@ -223,13 +223,13 @@ ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht) Bucket *old_buckets = ht->arData; HT_ASSERT_RC1(ht); - new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (ht)->u.flags & HASH_FLAG_PERSISTENT); + new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS; ht->nTableMask = HT_MIN_MASK; HT_SET_DATA_ADDR(ht, new_data); HT_HASH_RESET_PACKED(ht); memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed); - pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT); + pefree(old_data, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); } ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend_bool packed) @@ -246,7 +246,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend ZEND_ASSERT(ht->u.flags & HASH_FLAG_PACKED); if (nSize > ht->nTableSize) { ht->nTableSize = zend_hash_check_size(nSize); - HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT)); + HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT)); } } else { ZEND_ASSERT(!(ht->u.flags & HASH_FLAG_PACKED)); @@ -254,12 +254,12 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend void *new_data, *old_data = HT_GET_DATA_ADDR(ht); Bucket *old_buckets = ht->arData; nSize = zend_hash_check_size(nSize); - new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT); + new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); ht->nTableSize = nSize; ht->nTableMask = -ht->nTableSize; HT_SET_DATA_ADDR(ht, new_data); memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed); - pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT); + pefree(old_data, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zend_hash_rehash(ht); } } @@ -622,7 +622,7 @@ ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key, ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *str, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC) { - zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); + zend_string *key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zval *ret = _zend_hash_add_or_update_i(ht, key, pData, flag ZEND_FILE_LINE_RELAY_CC); zend_string_release(key); return ret; @@ -630,7 +630,7 @@ ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const c ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) { - zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); + zend_string *key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC); zend_string_release(key); return ret; @@ -638,7 +638,7 @@ ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *st ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) { - zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); + zend_string *key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC); zend_string_release(key); return ret; @@ -646,7 +646,7 @@ ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) { - zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); + zend_string *key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC); zend_string_release(key); return ret; @@ -654,7 +654,7 @@ ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *str, ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC) { - zend_string *key = zend_string_init(str, len, ht->u.flags & HASH_FLAG_PERSISTENT); + zend_string *key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zval *ret = _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC); zend_string_delref(key); return ret; @@ -839,12 +839,12 @@ static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht) uint32_t nSize = ht->nTableSize + ht->nTableSize; Bucket *old_buckets = ht->arData; - new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT); + new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); ht->nTableSize = nSize; ht->nTableMask = -ht->nTableSize; HT_SET_DATA_ADDR(ht, new_data); memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed); - pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT); + pefree(old_data, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); zend_hash_rehash(ht); } else { zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%u * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket) + sizeof(uint32_t), sizeof(Bucket)); @@ -1256,7 +1256,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_destroy(HashTable *ht) } else if (EXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) { return; } - pefree(HT_GET_DATA_ADDR(ht), ht->u.flags & HASH_FLAG_PERSISTENT); + pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); } ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht) @@ -1434,7 +1434,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_graceful_destroy(HashTable *ht) _zend_hash_del_el(ht, HT_IDX_TO_HASH(idx), p); } if (ht->u.flags & HASH_FLAG_INITIALIZED) { - pefree(HT_GET_DATA_ADDR(ht), ht->u.flags & HASH_FLAG_PERSISTENT); + pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); } SET_INCONSISTENT(HT_DESTROYED); @@ -1458,7 +1458,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_graceful_reverse_destroy(HashTable *ht) } if (ht->u.flags & HASH_FLAG_INITIALIZED) { - pefree(HT_GET_DATA_ADDR(ht), ht->u.flags & HASH_FLAG_PERSISTENT); + pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); } SET_INCONSISTENT(HT_DESTROYED); @@ -1739,7 +1739,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source) target->pDestructor = source->pDestructor; if (source->nNumUsed == 0) { - target->u.flags = (source->u.flags & ~(HASH_FLAG_INITIALIZED|HASH_FLAG_PACKED|HASH_FLAG_PERSISTENT)) | HASH_FLAG_STATIC_KEYS; + target->u.flags = (source->u.flags & ~(HASH_FLAG_INITIALIZED|HASH_FLAG_PACKED)) | HASH_FLAG_STATIC_KEYS; target->nTableMask = HT_MIN_MASK; target->nNumUsed = 0; target->nNumOfElements = 0; @@ -1747,7 +1747,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source) target->nInternalPointer = HT_INVALID_IDX; HT_SET_DATA_ADDR(target, &uninitialized_bucket); } else if (GC_FLAGS(source) & IS_ARRAY_IMMUTABLE) { - target->u.flags = source->u.flags & ~HASH_FLAG_PERSISTENT; + target->u.flags = source->u.flags; target->nTableMask = source->nTableMask; target->nNumUsed = source->nNumUsed; target->nNumOfElements = source->nNumOfElements; @@ -1764,7 +1764,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source) target->nInternalPointer = idx; } } else if (source->u.flags & HASH_FLAG_PACKED) { - target->u.flags = source->u.flags & ~HASH_FLAG_PERSISTENT; + target->u.flags = source->u.flags; target->nTableMask = source->nTableMask; target->nNumUsed = source->nNumUsed; target->nNumOfElements = source->nNumOfElements; @@ -1787,7 +1787,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source) target->nInternalPointer = idx; } } else { - target->u.flags = source->u.flags & ~HASH_FLAG_PERSISTENT; + target->u.flags = source->u.flags; target->nTableMask = source->nTableMask; target->nNextFreeElement = source->nNextFreeElement; target->nInternalPointer = source->nInternalPointer; @@ -2266,12 +2266,12 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co void *new_data, *old_data = HT_GET_DATA_ADDR(ht); Bucket *old_buckets = ht->arData; - new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (ht->u.flags & HASH_FLAG_PERSISTENT)); + new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (GC_FLAGS(ht) & IS_ARRAY_PERSISTENT)); ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS; ht->nTableMask = HT_MIN_MASK; HT_SET_DATA_ADDR(ht, new_data); memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed); - pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT & HASH_FLAG_PERSISTENT); + pefree(old_data, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); HT_HASH_RESET_PACKED(ht); } else { zend_hash_rehash(ht); diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h index e99224a0b4..e9518b8840 100644 --- a/Zend/zend_hash.h +++ b/Zend/zend_hash.h @@ -35,7 +35,6 @@ #define HASH_ADD_NEW (1<<3) #define HASH_ADD_NEXT (1<<4) -#define HASH_FLAG_PERSISTENT (1<<0) #define HASH_FLAG_PACKED (1<<2) #define HASH_FLAG_INITIALIZED (1<<3) #define HASH_FLAG_STATIC_KEYS (1<<4) /* long and interned strings */ @@ -619,7 +618,7 @@ static zend_always_inline void *zend_hash_add_mem(HashTable *ht, zend_string *ke ZVAL_PTR(&tmp, NULL); if ((zv = zend_hash_add(ht, key, &tmp))) { - Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + Z_PTR_P(zv) = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(Z_PTR_P(zv), pData, size); return Z_PTR_P(zv); } @@ -632,7 +631,7 @@ static zend_always_inline void *zend_hash_str_add_mem(HashTable *ht, const char ZVAL_PTR(&tmp, NULL); if ((zv = zend_hash_str_add(ht, str, len, &tmp))) { - Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + Z_PTR_P(zv) = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(Z_PTR_P(zv), pData, size); return Z_PTR_P(zv); } @@ -643,7 +642,7 @@ static zend_always_inline void *zend_hash_update_mem(HashTable *ht, zend_string { void *p; - p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(p, pData, size); return zend_hash_update_ptr(ht, key, p); } @@ -652,7 +651,7 @@ static zend_always_inline void *zend_hash_str_update_mem(HashTable *ht, const ch { void *p; - p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(p, pData, size); return zend_hash_str_update_ptr(ht, str, len, p); } @@ -695,7 +694,7 @@ static zend_always_inline void *zend_hash_index_add_mem(HashTable *ht, zend_ulon ZVAL_PTR(&tmp, NULL); if ((zv = zend_hash_index_add(ht, h, &tmp))) { - Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + Z_PTR_P(zv) = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(Z_PTR_P(zv), pData, size); return Z_PTR_P(zv); } @@ -720,7 +719,7 @@ static zend_always_inline void *zend_hash_index_update_mem(HashTable *ht, zend_u { void *p; - p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + p = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(p, pData, size); return zend_hash_index_update_ptr(ht, h, p); } @@ -731,7 +730,7 @@ static zend_always_inline void *zend_hash_next_index_insert_mem(HashTable *ht, v ZVAL_PTR(&tmp, NULL); if ((zv = zend_hash_next_index_insert(ht, &tmp))) { - Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT); + Z_PTR_P(zv) = pemalloc(size, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT); memcpy(Z_PTR_P(zv), pData, size); return Z_PTR_P(zv); } diff --git a/Zend/zend_types.h b/Zend/zend_types.h index d7381ab2d7..fc2510ae0f 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -456,9 +456,10 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define GC_INFO_MASK 0xffff0000 /* zval.value->gc.u.v.flags (common flags) */ -#define GC_PROTECTED (1<<0) /* used for array/object recursion detection */ -#define GC_IMMUTABLE (1<<1) /* string/array can't be canged in place */ -#define GC_COLLECTABLE (1<<7) +#define GC_COLLECTABLE (1<<0) +#define GC_PROTECTED (1<<1) /* used for recursion detection */ +#define GC_IMMUTABLE (1<<2) /* can't be canged in place */ +#define GC_PERSISTENT (1<<3) /* allocated using malloc */ #define GC_ARRAY (IS_ARRAY | (GC_COLLECTABLE << GC_FLAGS_SHIFT)) #define GC_OBJECT (IS_OBJECT | (GC_COLLECTABLE << GC_FLAGS_SHIFT)) @@ -491,20 +492,19 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) { #define RESET_CONSTANT_VISITED(p) Z_CONST_FLAGS_P(p) &= ~IS_CONSTANT_VISITED_MARK /* string flags (zval.value->gc.u.flags) */ -#define IS_STR_PERSISTENT (1<<0) /* allocated using malloc */ -#define IS_STR_INTERNED GC_IMMUTABLE /* interned string */ -#define IS_STR_PERMANENT (1<<2) /* relives request boundary */ +#define IS_STR_INTERNED GC_IMMUTABLE /* interned string */ +#define IS_STR_PERSISTENT GC_PERSISTENT /* allocated using malloc */ +#define IS_STR_PERMANENT (1<<4) /* relives request boundary */ /* array flags */ -#define IS_ARRAY_PROTECTED GC_PROTECTED #define IS_ARRAY_IMMUTABLE GC_IMMUTABLE +#define IS_ARRAY_PERSISTENT GC_PERSISTENT /* object flags (zval.value->gc.u.flags) */ -#define IS_OBJ_PROTECTED GC_PROTECTED -#define IS_OBJ_DESTRUCTOR_CALLED (1<<3) -#define IS_OBJ_FREE_CALLED (1<<4) -#define IS_OBJ_USE_GUARDS (1<<5) -#define IS_OBJ_HAS_GUARDS (1<<6) +#define IS_OBJ_DESTRUCTOR_CALLED (1<<4) +#define IS_OBJ_FREE_CALLED (1<<5) +#define IS_OBJ_USE_GUARDS (1<<6) +#define IS_OBJ_HAS_GUARDS (1<<7) /* Recursion protection macros must be used only for arrays and objects */ #define GC_IS_RECURSIVE(p) \ diff --git a/ext/standard/array.c b/ext/standard/array.c index 18a8a2e77f..50ca1d2c40 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -4521,7 +4521,7 @@ PHP_FUNCTION(array_unique) RETVAL_ARR(zend_array_dup(Z_ARRVAL_P(array))); /* 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)->u.flags & HASH_FLAG_PERSISTENT); + arTmp = (struct bucketindex *) pemalloc((Z_ARRVAL_P(array)->nNumOfElements + 1) * sizeof(struct bucketindex), GC_FLAGS(Z_ARRVAL_P(array)) & IS_ARRAY_PERSISTENT); for (i = 0, idx = 0; idx < Z_ARRVAL_P(array)->nNumUsed; idx++) { p = Z_ARRVAL_P(array)->arData + idx; if (Z_TYPE(p->val) == IS_UNDEF) continue; @@ -4556,7 +4556,7 @@ PHP_FUNCTION(array_unique) } } } - pefree(arTmp, Z_ARRVAL_P(array)->u.flags & HASH_FLAG_PERSISTENT); + pefree(arTmp, GC_FLAGS(Z_ARRVAL_P(array)) & IS_ARRAY_PERSISTENT); } /* }}} */ @@ -4811,7 +4811,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->u.flags & HASH_FLAG_PERSISTENT); + list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), GC_FLAGS(hash) & IS_ARRAY_PERSISTENT); lists[i] = list; ptrs[i] = list; for (idx = 0; idx < hash->nNumUsed; idx++) { @@ -4936,7 +4936,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->u.flags & HASH_FLAG_PERSISTENT); + pefree(lists[i], GC_FLAGS(hash) & IS_ARRAY_PERSISTENT); } PHP_ARRAY_CMP_FUNC_RESTORE(); @@ -5226,7 +5226,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->u.flags & HASH_FLAG_PERSISTENT); + list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), GC_FLAGS(hash) & IS_ARRAY_PERSISTENT); lists[i] = list; ptrs[i] = list; for (idx = 0; idx < hash->nNumUsed; idx++) { @@ -5349,7 +5349,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->u.flags & HASH_FLAG_PERSISTENT); + pefree(lists[i], GC_FLAGS(hash) & IS_ARRAY_PERSISTENT); } PHP_ARRAY_CMP_FUNC_RESTORE(); diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c index cc126d77be..c54f395ab9 100644 --- a/ext/standard/browscap.c +++ b/ext/standard/browscap.c @@ -301,7 +301,7 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb { browscap_parser_ctx *ctx = arg; browser_data *bdata = ctx->bdata; - int persistent = bdata->htab->u.flags & HASH_FLAG_PERSISTENT; + int persistent = GC_FLAGS(bdata->htab) & IS_ARRAY_PERSISTENT; if (!arg1) { return;