HASH_FLAG_PERSISTENT renamed into IS_ARRAY_PERSISTENT and moved into GC_FLAGS (to...

diff --git a/UPGRADING.INTERNALS b/UPGRADING.INTERNALS
index 1b6ba2adbba3f9357a7ff8718a273421c136545d..d314f8316a15879d6035fea76e9dda46a1f2b0ad 100644 (file)
--- 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 92f8358a0061dad750bf4272ea76ef8abc2138dd..07dcd26e8d71d20a781400b7dbb4a0d649762caf 100644 (file)
--- 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 e99224a0b4e51ac61efe8f3169880a0042017c05..e9518b88409be6ee4ed275fa3e31581e05b89fdb 100644 (file)
--- 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 d7381ab2d7d557a8a01225883aedebe7ea9f3324..fc2510ae0ff318cad11f4dcf70af1e71860606d9 100644 (file)
--- 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 18a8a2e77fb99ae6549aff4b94354a88be877d3d..50ca1d2c40bba4083c7a5810236243da8ec8899a 100644 (file)
--- 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 cc126d77be8a28e92ee7940f6f0c44ca8373b631..c54f395ab9b00c03e1965144ad23f94782c16fd8 100644 (file)
--- 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;