API cleanup.

Removed useless filename and lineno arguments, used in DEBUG build.
The patch doesn't break source compatibility of public API (only binary compatibility).

10 files changed, 143 insertions, 219 deletions

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index daa938a302..479b388b96 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1303,7 +1303,7 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties)
  * class and all props being public. If only a subset is given or the class
  * has protected members then you need to merge the properties separately by
  * calling zend_merge_properties(). */
-ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties) /* {{{ */
 {
 	if (UNEXPECTED(class_type->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) {
 		if (class_type->ce_flags & ZEND_ACC_INTERFACE) {
@@ -1340,9 +1340,9 @@ ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type
 }
 /* }}} */
 
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *class_type ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API int object_init_ex(zval *arg, zend_class_entry *class_type) /* {{{ */
 {
-	return _object_and_properties_init(arg, class_type, 0 ZEND_FILE_LINE_RELAY_CC);
+	return object_and_properties_init(arg, class_type, 0);
 }
 /* }}} */
 
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 3bd2471dda..98e8ae71dc 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -378,11 +378,9 @@ ZEND_API char *zend_get_type_by_const(int type);
 
 #define array_init(arg)				ZVAL_ARR((arg), zend_new_array(0))
 #define array_init_size(arg, size)	ZVAL_ARR((arg), zend_new_array(size))
-#define object_init_ex(arg, ce)	_object_init_ex((arg), (ce) ZEND_FILE_LINE_CC)
-#define object_and_properties_init(arg, ce, properties)	_object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC)
 ZEND_API int object_init(zval *arg);
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC);
-ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC);
+ZEND_API int object_init_ex(zval *arg, zend_class_entry *ce);
+ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties);
 ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
 ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties);
 ZEND_API void object_properties_load(zend_object *object, HashTable *properties);
diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index b4a62b1649..0b516b28e6 100644
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -214,14 +214,14 @@ ZEND_API void ZEND_FASTCALL _zend_hash_init(HashTable *ht, uint32_t nSize, dtor_
 	_zend_hash_init_int(ht, nSize, pDestructor, persistent);
 }
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(ZEND_FILE_LINE_D)
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(void)
 {
 	HashTable *ht = emalloc(sizeof(HashTable));
 	_zend_hash_init_int(ht, HT_MIN_SIZE, ZVAL_PTR_DTOR, 0);
 	return ht;
 }
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t nSize ZEND_FILE_LINE_DC)
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t nSize)
 {
 	HashTable *ht = emalloc(sizeof(HashTable));
 	_zend_hash_init_int(ht, nSize, ZVAL_PTR_DTOR, 0);
@@ -647,7 +647,7 @@ static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *h
 	return NULL;
 }
 
-static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag)
 {
 	zend_ulong h;
 	uint32_t nIndex;
@@ -732,7 +732,7 @@ add_to_hash:
 	return &p->val;
 }
 
-static zend_always_inline zval *_zend_hash_str_add_or_update_i(HashTable *ht, const char *str, size_t len, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_str_add_or_update_i(HashTable *ht, const char *str, size_t len, zend_ulong h, zval *pData, uint32_t flag)
 {
 	zend_string *key;
 	uint32_t nIndex;
@@ -799,80 +799,80 @@ add_to_hash:
 	return &p->val;
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag)
 {
 	if (flag == HASH_ADD) {
-		return _zend_hash_add(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_add(ht, key, pData);
 	} else if (flag == HASH_ADD_NEW) {
-		return _zend_hash_add_new(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_add_new(ht, key, pData);
 	} else if (flag == HASH_UPDATE) {
-		return _zend_hash_update(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_update(ht, key, pData);
 	} else {
 		ZEND_ASSERT(flag == (HASH_UPDATE|HASH_UPDATE_INDIRECT));
-		return _zend_hash_update_ind(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_update_ind(ht, key, pData);
 	}
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add(HashTable *ht, zend_string *key, zval *pData)
 {
-	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_update(HashTable *ht, zend_string *key, zval *pData)
 {
-	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_update_ind(HashTable *ht, zend_string *key, zval *pData)
 {
-	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData)
 {
-	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW);
 }
 
-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_API zval* ZEND_FASTCALL zend_hash_str_add_or_update(HashTable *ht, const char *str, size_t len, zval *pData, uint32_t flag)
 {
 	if (flag == HASH_ADD) {
-		return _zend_hash_str_add(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_str_add(ht, str, len, pData);
 	} else if (flag == HASH_ADD_NEW) {
-		return _zend_hash_str_add_new(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_str_add_new(ht, str, len, pData);
 	} else if (flag == HASH_UPDATE) {
-		return _zend_hash_str_update(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_str_update(ht, str, len, pData);
 	} else {
 		ZEND_ASSERT(flag == (HASH_UPDATE|HASH_UPDATE_INDIRECT));
-		return _zend_hash_str_update_ind(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_str_update_ind(ht, str, len, pData);
 	}
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData)
 {
 	zend_ulong h = zend_hash_func(str, len);
 
-	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE);
 }
 
-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_API zval* ZEND_FASTCALL zend_hash_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData)
 {
 	zend_ulong h = zend_hash_func(str, len);
 
-	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData)
 {
 	zend_ulong h = zend_hash_func(str, len);
 
-	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD);
 }
 
-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_API zval* ZEND_FASTCALL zend_hash_str_add_new(HashTable *ht, const char *str, size_t len, zval *pData)
 {
 	zend_ulong h = zend_hash_func(str, len);
 
-	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD_NEW);
 }
 
 ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_empty_element(HashTable *ht, zend_ulong h)
@@ -899,7 +899,7 @@ ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_empty_element(HashTable *ht, cons
 	return zend_hash_str_add(ht, str, len, &dummy);
 }
 
-static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag)
 {
 	uint32_t nIndex;
 	uint32_t idx;
@@ -983,47 +983,47 @@ add:
 	return &p->val;
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag)
 {
 	if (flag == HASH_ADD) {
-		return _zend_hash_index_add(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_index_add(ht, h, pData);
 	} else if (flag == (HASH_ADD|HASH_ADD_NEW)) {
-		return _zend_hash_index_add_new(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_index_add_new(ht, h, pData);
 	} else if (flag == (HASH_ADD|HASH_ADD_NEXT)) {
 		ZEND_ASSERT(h == ht->nNextFreeElement);
-		return _zend_hash_next_index_insert(ht, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_next_index_insert(ht, pData);
 	} else if (flag == (HASH_ADD|HASH_ADD_NEW|HASH_ADD_NEXT)) {
 		ZEND_ASSERT(h == ht->nNextFreeElement);
-		return _zend_hash_next_index_insert_new(ht, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_next_index_insert_new(ht, pData);
 	} else {
 		ZEND_ASSERT(flag == HASH_UPDATE);
-		return _zend_hash_index_update(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+		return zend_hash_index_update(ht, h, pData);
 	}
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData)
 {
-	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData)
 {
-	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD | HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD | HASH_ADD_NEW);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData)
 {
-	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_UPDATE);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert(HashTable *ht, zval *pData)
 {
-	return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEXT ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEXT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert_new(HashTable *ht, zval *pData)
 {
-	return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEW | HASH_ADD_NEXT ZEND_FILE_LINE_RELAY_CC);
+	return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEW | HASH_ADD_NEXT);
 }
 
 static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht)
@@ -1991,7 +1991,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
 }
 
 
-ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite)
 {
     uint32_t idx;
 	Bucket *p;
@@ -2010,7 +2010,7 @@ ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *sourc
 			    continue;
 			}
 			if (p->key) {
-				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT);
 				if (pCopyConstructor) {
 					pCopyConstructor(t);
 				}
@@ -2030,7 +2030,7 @@ ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *sourc
 			    continue;
 			}
 			if (p->key) {
-				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+				t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT);
 				if (t && pCopyConstructor) {
 					pCopyConstructor(t);
 				}
diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 984730e5fd..ac90451e01 100644
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -107,53 +107,24 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 ZEND_API void ZEND_FASTCALL zend_hash_discard(HashTable *ht, uint32_t nNumUsed);
 
 /* additions/updates/changes */
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_update(ht, key, pData) \
-		_zend_hash_update(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_update_ind(ht, key, pData) \
-		_zend_hash_update_ind(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_add(ht, key, pData) \
-		_zend_hash_add(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_add_new(ht, key, pData) \
-		_zend_hash_add_new(ht, key, pData ZEND_FILE_LINE_CC)
-
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *key, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_str_update(ht, key, len, pData) \
-		_zend_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_update_ind(ht, key, len, pData) \
-		_zend_hash_str_update_ind(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_add(ht, key, len, pData) \
-		_zend_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_add_new(ht, key, len, pData) \
-		_zend_hash_str_add_new(ht, key, len, pData ZEND_FILE_LINE_CC)
-
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_index_add(ht, h, pData) \
-		_zend_hash_index_add(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_index_add_new(ht, h, pData) \
-		_zend_hash_index_add_new(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_index_update(ht, h, pData) \
-		_zend_hash_index_update(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_next_index_insert(ht, pData) \
-		_zend_hash_next_index_insert(ht, pData ZEND_FILE_LINE_CC)
-#define zend_hash_next_index_insert_new(ht, pData) \
-		_zend_hash_next_index_insert_new(ht, pData ZEND_FILE_LINE_CC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_update(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_update_ind(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_add(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_new(HashTable *ht, zend_string *key,zval *pData);
+
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_or_update(HashTable *ht, const char *key, size_t len, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update_ind(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_new(HashTable *ht, const char *key, size_t len, zval *pData);
+
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert(HashTable *ht, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert_new(HashTable *ht, zval *pData);
 
 ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_empty_element(HashTable *ht, zend_ulong h);
 ZEND_API zval* ZEND_FASTCALL zend_hash_add_empty_element(HashTable *ht, zend_string *key);
@@ -267,7 +238,7 @@ ZEND_API void  ZEND_FASTCALL zend_hash_internal_pointer_end_ex(HashTable *ht, Ha
 
 /* Copying, merging and sorting */
 ZEND_API void  ZEND_FASTCALL zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor);
-ZEND_API void  ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite ZEND_FILE_LINE_DC);
+ZEND_API void  ZEND_FASTCALL zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite);
 ZEND_API void  ZEND_FASTCALL zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API void  zend_hash_bucket_swap(Bucket *p, Bucket *q);
 ZEND_API void  zend_hash_bucket_renum_swap(Bucket *p, Bucket *q);
@@ -276,9 +247,6 @@ ZEND_API int   zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t
 ZEND_API int   ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, zend_bool renumber);
 ZEND_API zval* ZEND_FASTCALL zend_hash_minmax(const HashTable *ht, compare_func_t compar, uint32_t flag);
 
-#define zend_hash_merge(target, source, pCopyConstructor, overwrite)					\
-	_zend_hash_merge(target, source, pCopyConstructor, overwrite ZEND_FILE_LINE_CC)
-
 #define zend_hash_sort(ht, compare_func, renumber) \
 	zend_hash_sort_ex(ht, zend_sort, compare_func, renumber)
 
@@ -294,20 +262,20 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht);
 # define zend_new_array(size) \
 	(__builtin_constant_p(size) ? \
 		((((uint32_t)(size)) <= HT_MIN_SIZE) ? \
-			_zend_new_array_0(ZEND_FILE_LINE_C) \
+			_zend_new_array_0() \
 		: \
-			_zend_new_array((size) ZEND_FILE_LINE_CC) \
+			_zend_new_array((size)) \
 		) \
 	: \
-		_zend_new_array((size) ZEND_FILE_LINE_CC) \
+		_zend_new_array((size)) \
 	)
 #else
 # define zend_new_array(size) \
-	_zend_new_array(size ZEND_FILE_LINE_CC)
+	_zend_new_array(size)
 #endif
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(ZEND_FILE_LINE_D);
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t size ZEND_FILE_LINE_DC);
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(void);
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t size);
 ZEND_API uint32_t zend_array_count(HashTable *ht);
 ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source);
 ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht);
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 10b065bb79..ea3f2e0ba7 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -519,7 +519,7 @@ try_again:
 }
 /* }}} */
 
-ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op) /* {{{ */
 {
 	if (Z_TYPE_P(op) == IS_DOUBLE) {
 		zend_string *str;
@@ -528,12 +528,12 @@ ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {
 		str = zend_strpprintf_unchecked(0, "%.*H", (int) EG(precision), dval);
 		ZVAL_NEW_STR(op, str);
 	} else {
-		_convert_to_string(op ZEND_FILE_LINE_CC);
+		_convert_to_string(op);
 	}
 }
 /* }}} */
 
-ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op) /* {{{ */
 {
 try_again:
 	switch (Z_TYPE_P(op)) {
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 46c6f18774..1de69f6b9a 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -247,8 +247,8 @@ ZEND_API int ZEND_FASTCALL increment_function(zval *op1);
 ZEND_API int ZEND_FASTCALL decrement_function(zval *op2);
 
 ZEND_API void ZEND_FASTCALL convert_scalar_to_number(zval *op);
-ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC);
-ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op);
+ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_long(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_double(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_long_base(zval *op, int base);
@@ -296,8 +296,8 @@ static zend_always_inline void zend_tmp_string_release(zend_string *tmp) {
 #define _zval_get_double_func(op) zval_get_double_func(op)
 #define _zval_get_string_func(op) zval_get_string_func(op)
 
-#define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); }
-#define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
+#define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op)); }
+#define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op)); }
 
 
 ZEND_API int ZEND_FASTCALL zend_is_true(zval *op);
diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c
index f5d210b724..9d48c7425e 100644
--- a/Zend/zend_ts_hash.c
+++ b/Zend/zend_ts_hash.c
@@ -89,45 +89,45 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht)
 	end_write(ht);
 }
 
-ZEND_API zval *_zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData)
 {
 	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_add(TS_HASH(ht), key, pData ZEND_FILE_LINE_RELAY_CC);
+	retval = zend_hash_add(TS_HASH(ht), key, pData);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData)
 {
 	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_update(TS_HASH(ht), key, pData ZEND_FILE_LINE_RELAY_CC);
+	retval = zend_hash_update(TS_HASH(ht), key, pData);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData)
 {
 	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_next_index_insert(TS_HASH(ht), pData ZEND_FILE_LINE_RELAY_CC);
+	retval = zend_hash_next_index_insert(TS_HASH(ht), pData);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData)
 {
 	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_index_update(TS_HASH(ht), h, pData ZEND_FILE_LINE_RELAY_CC);
+	retval = zend_hash_index_update(TS_HASH(ht), h, pData);
 	end_write(ht);
 
 	return retval;
@@ -356,7 +356,7 @@ ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t le
 	return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData)
 {
 	zval *retval;
 
@@ -367,7 +367,7 @@ ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t
 	return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData)
 {
 	zval *retval;
 
diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h
index ef882e0820..35760b92ca 100644
--- a/Zend/zend_ts_hash.h
+++ b/Zend/zend_ts_hash.h
@@ -48,16 +48,10 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht);
 
 
 /* additions/updates/changes */
-#define zend_ts_hash_update(ht, key, pData) \
-		_zend_ts_hash_update(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_add(ht, key, pData) \
-		_zend_ts_hash_add(ht, key, pData ZEND_FILE_LINE_CC)
-
-#define zend_ts_hash_index_update(ht, h, pData) \
-		_zend_ts_hash_index_update(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_next_index_insert(ht, pData) \
-		_zend_ts_hash_next_index_insert(ht, ht->nNextFreeElement, pData ZEND_FILE_LINE_CC)
-
+ZEND_API zval *zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData);
+ZEND_API zval *zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData);
+ZEND_API zval *zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval *zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData);
 ZEND_API zval* zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key);
 
 ZEND_API void zend_ts_hash_graceful_destroy(TsHashTable *ht);
@@ -100,13 +94,8 @@ void zend_ts_hash_display(TsHashTable *ht);
 #endif
 
 ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len);
-ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_ts_hash_str_update(ht, key, len, pData) \
-		_zend_ts_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_str_add(ht, key, len, pData) \
-		_zend_ts_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
+ZEND_API zval *zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval *zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData);
 
 static zend_always_inline void *zend_ts_hash_str_find_ptr(TsHashTable *ht, const char *str, size_t len)
 {
diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index bd292450d7..e04926aac0 100644
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -28,15 +28,15 @@
 #include "zend_constants.h"
 #include "zend_list.h"
 
-static void ZEND_FASTCALL zend_string_destroy(zend_string *str ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref ZEND_FILE_LINE_DC);
+static void ZEND_FASTCALL zend_string_destroy(zend_string *str);
+static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref);
+static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref);
 
 #if ZEND_DEBUG
-static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FILE_LINE_DC);
+static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr);
+static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj);
+static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res);
+static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast);
 #else
 # define zend_array_destroy_wrapper    zend_array_destroy
 # define zend_object_destroy_wrapper   zend_objects_store_del
@@ -44,7 +44,7 @@ static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FI
 # define zend_ast_ref_destroy_wrapper  zend_ast_ref_destroy
 #endif
 
-typedef void (ZEND_FASTCALL *zend_rc_dtor_func_t)(zend_refcounted *p ZEND_FILE_LINE_DC);
+typedef void (ZEND_FASTCALL *zend_rc_dtor_func_t)(zend_refcounted *p);
 
 static const zend_rc_dtor_func_t zend_rc_dtor_func[] = {
 	/* IS_UNDEF        */ (zend_rc_dtor_func_t)zend_empty_destroy,
@@ -61,60 +61,60 @@ static const zend_rc_dtor_func_t zend_rc_dtor_func[] = {
 	/* IS_CONSTANT_AST */ (zend_rc_dtor_func_t)zend_ast_ref_destroy_wrapper
 };
 
-ZEND_API void ZEND_FASTCALL _rc_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL rc_dtor_func(zend_refcounted *p)
 {
 	ZEND_ASSERT(GC_TYPE(p) <= IS_CONSTANT_AST);
-	zend_rc_dtor_func[GC_TYPE(p)](p ZEND_FILE_LINE_RELAY_CC);
+	zend_rc_dtor_func[GC_TYPE(p)](p);
 }
 
-static void ZEND_FASTCALL zend_string_destroy(zend_string *str ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_string_destroy(zend_string *str)
 {
-	CHECK_ZVAL_STRING_REL(str);
+	CHECK_ZVAL_STRING(str);
 	ZEND_ASSERT(!ZSTR_IS_INTERNED(str));
 	ZEND_ASSERT(GC_REFCOUNT(str) == 0);
 	ZEND_ASSERT(!(GC_FLAGS(str) & IS_STR_PERSISTENT));
 	efree(str);
 }
 
-static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref)
 {
-	i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC);
+	i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_CC);
 	efree_size(ref, sizeof(zend_reference));
 }
 
-static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref)
 {
 }
 
 #if ZEND_DEBUG
-static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr)
 {
 	zend_array_destroy(arr);
 }
 
-static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj)
 {
 	zend_objects_store_del(obj);
 }
 
-static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res)
 {
 	zend_list_free(res);
 }
 
-static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast)
 {
 	zend_ast_ref_destroy(ast);
 }
 #endif
 
-ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void zval_ptr_dtor(zval *zval_ptr) /* {{{ */
 {
-	i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+	i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_CC);
 }
 /* }}} */
 
-ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void zval_internal_ptr_dtor(zval *zval_ptr) /* {{{ */
 {
 	if (Z_REFCOUNTED_P(zval_ptr)) {
 		zend_refcounted *ref = Z_COUNTED_P(zval_ptr);
@@ -123,7 +123,7 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ *
 			if (Z_TYPE_P(zval_ptr) == IS_STRING) {
 				zend_string *str = (zend_string*)ref;
 
-				CHECK_ZVAL_STRING_REL(str);
+				CHECK_ZVAL_STRING(str);
 				ZEND_ASSERT(!ZSTR_IS_INTERNED(str));
 				ZEND_ASSERT((GC_FLAGS(str) & IS_STR_PERSISTENT));
 				free(str);
@@ -150,32 +150,17 @@ ZEND_API void zval_add_ref(zval *p)
 	}
 }
 
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue)
 {
 	if (EXPECTED(Z_TYPE_P(zvalue) == IS_ARRAY)) {
 		ZVAL_ARR(zvalue, zend_array_dup(Z_ARRVAL_P(zvalue)));
 	} else if (EXPECTED(Z_TYPE_P(zvalue) == IS_STRING)) {
 		ZEND_ASSERT(!ZSTR_IS_INTERNED(Z_STR_P(zvalue)));
-		CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+		CHECK_ZVAL_STRING(Z_STR_P(zvalue));
 		ZVAL_NEW_STR(zvalue, zend_string_dup(Z_STR_P(zvalue), 0));
 	}
 }
 
-
-#if ZEND_DEBUG
-ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr)
-{
-
-	i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_CC);
-}
-
-
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zval_ptr)
-{
-	zval_internal_ptr_dtor(zval_ptr);
-}
-#endif
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h
index 2dcd106da6..3d1e390994 100644
--- a/Zend/zend_variables.h
+++ b/Zend/zend_variables.h
@@ -28,16 +28,13 @@
 
 BEGIN_EXTERN_C()
 
-ZEND_API void ZEND_FASTCALL _rc_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC);
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL rc_dtor_func(zend_refcounted *p);
+ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue);
 
-#define rc_dtor_func(ref)         _rc_dtor_func(ref ZEND_FILE_LINE_CC)
-#define zval_copy_ctor_func(zv)   _zval_copy_ctor_func(zv ZEND_FILE_LINE_CC)
-
-static zend_always_inline void _zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_ptr_dtor_nogc(zval *zval_ptr)
 {
 	if (Z_REFCOUNTED_P(zval_ptr) && !Z_DELREF_P(zval_ptr)) {
-		_rc_dtor_func(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
+		rc_dtor_func(Z_COUNTED_P(zval_ptr));
 	}
 }
 
@@ -46,14 +43,14 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC)
 	if (Z_REFCOUNTED_P(zval_ptr)) {
 		zend_refcounted *ref = Z_COUNTED_P(zval_ptr);
 		if (!GC_DELREF(ref)) {
-			_rc_dtor_func(ref ZEND_FILE_LINE_RELAY_CC);
+			rc_dtor_func(ref);
 		} else {
 			gc_check_possible_root(ref);
 		}
 	}
 }
 
-static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_copy_ctor(zval *zvalue)
 {
 	if (Z_TYPE_P(zvalue) == IS_ARRAY) {
 		ZVAL_ARR(zvalue, zend_array_dup(Z_ARR_P(zvalue)));
@@ -62,7 +59,7 @@ static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
 	}
 }
 
-static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_opt_copy_ctor(zval *zvalue)
 {
 	if (Z_OPT_TYPE_P(zvalue) == IS_ARRAY) {
 		ZVAL_ARR(zvalue, zend_array_dup(Z_ARR_P(zvalue)));
@@ -81,35 +78,22 @@ static zend_always_inline void zval_ptr_dtor_str(zval *zval_ptr)
 	}
 }
 
-ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC);
-#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_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)
-#define zval_internal_ptr_dtor(zvalue) _zval_internal_ptr_dtor((zvalue) ZEND_FILE_LINE_CC)
+ZEND_API void zval_ptr_dtor(zval *zval_ptr);
+ZEND_API void zval_internal_ptr_dtor(zval *zvalue);
 
 /* Kept for compatibility */
 #define zval_dtor(zvalue) zval_ptr_dtor_nogc(zvalue)
-#define zval_internal_dtor(zvalue) _zval_internal_ptr_dtor((zvalue) ZEND_FILE_LINE_CC)
-#define zval_dtor_func _rc_dtor_func
-
-#if ZEND_DEBUG
-ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr);
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zvalue);
-#define zval_ptr_dtor_wrapper _zval_ptr_dtor_wrapper
-#define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor_wrapper
-#else
-#define zval_ptr_dtor_wrapper _zval_ptr_dtor
-#define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor
-#endif
+#define zval_internal_dtor(zvalue) zval_internal_ptr_dtor(zvalue)
+#define zval_dtor_func rc_dtor_func
+#define zval_ptr_dtor_wrapper zval_ptr_dtor
+#define zval_internal_ptr_dtor_wrapper zval_internal_ptr_dtor
 
 ZEND_API void zval_add_ref(zval *p);
 
 END_EXTERN_C()
 
-#define ZVAL_PTR_DTOR zval_ptr_dtor_wrapper
-#define ZVAL_INTERNAL_PTR_DTOR zval_internal_ptr_dtor_wrapper
+#define ZVAL_PTR_DTOR zval_ptr_dtor
+#define ZVAL_INTERNAL_PTR_DTOR zval_internal_ptr_dtor
 
 #endif