mirror of
https://github.com/php/php-src.git
synced 2024-09-21 18:07:23 +00:00
HASH_FLAG_PERSISTENT renamed into IS_ARRAY_PERSISTENT and moved into GC_FLAGS (to be consistent with IS_STR_PERSISTENT).
This commit is contained in:
parent
cb9d81ef4f
commit
254b74b85f
@ -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
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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) \
|
||||
|
@ -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();
|
||||
|
@ -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;
|
||||
|
Loading…
Reference in New Issue
Block a user