Improve tracking

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index cd2d0f85b3b5f66f0db9119a9f09d485a835d369..7c7e0fe31de92f127a714f08c329c98bd6e332a3 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -645,7 +645,7 @@ ZEND_API int _array_init(zval *arg ZEND_FILE_LINE_DC)
 {
        ALLOC_HASHTABLE_REL(arg->value.ht);
 
-       zend_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0);
+       _zend_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0 ZEND_FILE_LINE_RELAY_CC);
        arg->type = IS_ARRAY;
        return SUCCESS;
 }

diff --git a/Zend/zend_alloc.h b/Zend/zend_alloc.h
index df085e46cb157fbbad4c9bee74a8601483e224e8..a8a8886f470f4ab402f9fcca6eb9c6f7ada1b827 100644 (file)
--- a/Zend/zend_alloc.h
+++ b/Zend/zend_alloc.h
@@ -113,6 +113,13 @@ ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZE
 #define perealloc_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable((ptr), (size)))
 #define pestrdup(s, persistent) ((persistent)?strdup(s):estrdup(s))
 
+#define pemalloc_rel(size, persistent) ((persistent)?malloc(size):emalloc_rel(size))
+#define pefree_rel(ptr, persistent)    ((persistent)?free(ptr):efree_rel(ptr))
+#define pecalloc_rel(nmemb, size, persistent) ((persistent)?calloc((nmemb), (size)):ecalloc_rel((nmemb), (size)))
+#define perealloc_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_rel((ptr), (size)))
+#define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
+#define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
+
 #define safe_estrdup(ptr)  ((ptr)?(estrdup(ptr)):(empty_string))
 #define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):(empty_string))
 

diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index 3c30a9dd52ba663d1c718fa9430e1ccc8797974f..fac4d8f64aedfc9478e6e24cba069e5663bcc52f 100644 (file)
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -103,16 +103,16 @@ ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength)
 #define UPDATE_DATA(ht, p, pData, nDataSize)                                                                                   \
        if (nDataSize == sizeof(void*)) {                                                                                                       \
                if (!(p)->pDataPtr) {                                                                                                                   \
-                       pefree((p)->pData, (ht)->persistent);                                                                           \
+                       pefree_rel((p)->pData, (ht)->persistent);                                                                               \
                }                                                                                                                                                               \
                memcpy(&(p)->pDataPtr, pData, sizeof(void *));                                                                  \
                (p)->pData = &(p)->pDataPtr;                                                                                                    \
        } else {                                                                                                                                                        \
                if ((p)->pDataPtr) {                                                                                                                    \
-                       (p)->pData = (void *) pemalloc(nDataSize, (ht)->persistent);                            \
+                       (p)->pData = (void *) pemalloc_rel(nDataSize, (ht)->persistent);                                \
                        (p)->pDataPtr=NULL;                                                                                                                     \
                } else {                                                                                                                                                \
-                       (p)->pData = (void *) perealloc((p)->pData, nDataSize, (ht)->persistent);       \
+                       (p)->pData = (void *) perealloc_rel((p)->pData, nDataSize, (ht)->persistent);   \
                        /* (p)->pDataPtr is already NULL so no need to initialize it */                         \
                }                                                                                                                                                               \
                memcpy((p)->pData, pData, nDataSize);                                                                                   \
@@ -123,9 +123,9 @@ ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength)
                memcpy(&(p)->pDataPtr, pData, sizeof(void *));                                  \
                (p)->pData = &(p)->pDataPtr;                                                                    \
        } else {                                                                                                                        \
-               (p)->pData = (void *) pemalloc(nDataSize, (ht)->persistent);    \
+               (p)->pData = (void *) pemalloc_rel(nDataSize, (ht)->persistent);        \
                if (!(p)->pData) {                                                                                              \
-                       pefree(p, (ht)->persistent);                                                            \
+                       pefree_rel(p, (ht)->persistent);                                                                \
                        return FAILURE;                                                                                         \
                }                                                                                                                               \
                memcpy((p)->pData, pData, nDataSize);                                                   \
@@ -186,7 +186,7 @@ ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProt
 
 
 
-ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        ulong h;
        uint nIndex;
@@ -256,7 +256,7 @@ ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength
        return SUCCESS;
 }
 
-ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        uint nIndex;
        Bucket *p;
@@ -333,7 +333,7 @@ ZEND_API int zend_hash_add_empty_element(HashTable *ht, char *arKey, uint nKeyLe
 }
 
 
-ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        uint nIndex;
        Bucket *p;
@@ -374,7 +374,7 @@ ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void
                }
                p = p->pNext;
        }
-       p = (Bucket *) pemalloc(sizeof(Bucket)-1, ht->persistent);
+       p = (Bucket *) pemalloc_rel(sizeof(Bucket)-1, ht->persistent);
        if (!p) {
                return FAILURE;
        }
@@ -764,7 +764,7 @@ ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_fun
 }
 
 
-ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite)
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC)
 {
        Bucket *p;
        void *t;
@@ -776,7 +776,7 @@ ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_fu
     p = source->pListHead;
        while (p) {
                if (p->nKeyLength>0) {
-                       if (zend_hash_add_or_update(target, p->arKey, p->nKeyLength, p->pData, size, &t, mode)==SUCCESS && pCopyConstructor) {
+                       if (_zend_hash_add_or_update(target, p->arKey, p->nKeyLength, p->pData, size, &t, mode ZEND_FILE_LINE_RELAY_CC)==SUCCESS && pCopyConstructor) {
                                pCopyConstructor(t);
                        }
                } else {

diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index ce188fab92fddaf0e98516d22fc3e9c1cf3e79d9..7cbe02605ee4f47b5391e7e2918380a1ba257a1f 100644 (file)
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -98,23 +98,23 @@ ZEND_API void zend_hash_clean(HashTable *ht);
 #define zend_hash_init_ex(ht, nSize, pHashFunction, pDestructor, persistent, bApplyProtection)         _zend_hash_init_ex((ht), (nSize), (pHashFunction), (pDestructor), (persistent), (bApplyProtection) ZEND_FILE_LINE_CC)
 
 /* additions/updates/changes */
-ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-               zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-               zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD)
+               _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-               zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-               zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD)
+               _zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_index_update(ht, h, pData, nDataSize, pDest) \
-               zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
-               zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT)
+               _zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
 
 ZEND_API int zend_hash_add_empty_element(HashTable *ht, char *arKey, uint nKeyLength);
 
@@ -194,12 +194,15 @@ ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos
 
 /* Copying, merging and sorting */
 ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite);
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC);
 ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber TSRMLS_DC);
 ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC);
 ZEND_API int zend_hash_minmax(HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC);
 
+#define zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite)                                        \
+       _zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite ZEND_FILE_LINE_CC)
+
 ZEND_API int zend_hash_num_elements(HashTable *ht);
 
 ZEND_API int zend_hash_rehash(HashTable *ht);

diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c
index 5fca8292a8eb41d72328a3c3193d64dfa14d9f81..c8897806b166cfce725fb9deefdd958a686a7bb9 100644 (file)
--- a/Zend/zend_ts_hash.c
+++ b/Zend/zend_ts_hash.c
@@ -94,34 +94,34 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht)
        zend_hash_clean(TS_HASH(ht));
 }
 
-ZEND_API int zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        int retval;
 
        begin_write(ht);
-       retval = zend_hash_add_or_update(TS_HASH(ht), arKey, nKeyLength, pData, nDataSize, pDest, flag);
+       retval = _zend_hash_add_or_update(TS_HASH(ht), arKey, nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
        end_write(ht);
 
        return retval;
 }
 
-ZEND_API int zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        int retval;
 
        begin_write(ht);
-       retval = zend_hash_quick_add_or_update(TS_HASH(ht), arKey, nKeyLength, h, pData, nDataSize, pDest, flag);
+       retval = _zend_hash_quick_add_or_update(TS_HASH(ht), arKey, nKeyLength, h, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
        end_write(ht);
 
        return retval;
 }
 
-ZEND_API int zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag)
+ZEND_API int _zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
        int retval;
 
        begin_write(ht);
-       retval = zend_hash_index_update_or_next_insert(TS_HASH(ht), h, pData, nDataSize, pDest, flag);
+       retval = _zend_hash_index_update_or_next_insert(TS_HASH(ht), h, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
        end_write(ht);
 
        return retval;

diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h
index 01b2de89c66a35daa76d0ebc63b9c91c210e5236..ae4a791e8930478e15d141d27da9ee67cbec6da6 100644 (file)
--- a/Zend/zend_ts_hash.h
+++ b/Zend/zend_ts_hash.h
@@ -49,23 +49,23 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht);
 
 
 /* additions/updates/changes */
-ZEND_API int zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_ts_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-               zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_ts_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-               zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD)
+               _zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_ts_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-               zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_ts_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-               zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD)
+               _zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
+ZEND_API int _zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_ts_hash_index_update(ht, h, pData, nDataSize, pDest) \
-               zend_ts_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE)
+               _zend_ts_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_ts_hash_next_index_insert(ht, pData, nDataSize, pDest) \
-               zend_ts_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT)
+               _zend_ts_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
 
 ZEND_API int zend_ts_hash_add_empty_element(TsHashTable *ht, char *arKey, uint nKeyLength);