archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-15 21:48:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

MFH: Added macros for managing zval refcounts and is_ref statuses

Browse source
This commit is contained in:
Yiduo (David) Wang 2007-10-07 05:22:07 +00:00
parent ca4c55ad3a
commit 4b4d634cb9
79 changed files with 924 additions and 864 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Zend/zend.c
View file

@ -236,7 +236,7 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
if (!Z_OBJ_HANDLER_P(expr, cast_object) && Z_OBJ_HANDLER_P(expr, get)) { if (!Z_OBJ_HANDLER_P(expr, cast_object) && Z_OBJ_HANDLER_P(expr, get)) {
zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC); zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
z->refcount++; Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) { if(Z_TYPE_P(z) != IS_OBJECT) {
zend_make_printable_zval(z, expr_copy, use_copy); zend_make_printable_zval(z, expr_copy, use_copy);
if (*use_copy) { if (*use_copy) {
@ -629,8 +629,8 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
/* This zval can be used to initialize allocate zval's to an uninit'ed value */ /* This zval can be used to initialize allocate zval's to an uninit'ed value */
zval_used_for_init.is_ref = 0; Z_UNSET_ISREF(zval_used_for_init);
zval_used_for_init.refcount = 1; Z_SET_REFCOUNT(zval_used_for_init, 1);
zval_used_for_init.type = IS_NULL; zval_used_for_init.type = IS_NULL;
#ifdef ZTS #ifdef ZTS

110
Zend/zend.h
View file

@ -295,12 +295,77 @@ typedef union _zvalue_value {
struct _zval_struct { struct _zval_struct {
/* Variable information */ /* Variable information */
zvalue_value value; /* value */ zvalue_value value; /* value */
zend_uint refcount; zend_uint refcount__gc;
zend_uchar type; /* active type */ zend_uchar type; /* active type */
zend_uchar is_ref; zend_uchar is_ref__gc;
zend_uchar idx_type; /* type of element's index in constant array */ zend_uchar idx_type; /* type of element's index in constant array */
}; };
#define Z_REFCOUNT_PP(ppz) Z_REFCOUNT_P(*(ppz))
#define Z_SET_REFCOUNT_PP(ppz, rc) Z_SET_REFCOUNT_P(*(ppz), rc)
#define Z_ADDREF_PP(ppz) Z_ADDREF_P(*(ppz))
#define Z_DELREF_PP(ppz) Z_DELREF_P(*(ppz))
#define Z_ISREF_PP(ppz) Z_ISREF_P(*(ppz))
#define Z_SET_ISREF_PP(ppz) Z_SET_ISREF_P(*(ppz))
#define Z_UNSET_ISREF_PP(ppz) Z_UNSET_ISREF_P(*(ppz))
#define Z_SET_ISREF_TO_PP(ppz, isref) Z_SET_ISREF_TO_P(*(ppz), isref)
#define Z_REFCOUNT_P(pz) zval_refcount_p(pz)
#define Z_SET_REFCOUNT_P(pz, rc) zval_set_refcount_p(pz, rc)
#define Z_ADDREF_P(pz) zval_addref_p(pz)
#define Z_DELREF_P(pz) zval_delref_p(pz)
#define Z_ISREF_P(pz) zval_isref_p(pz)
#define Z_SET_ISREF_P(pz) zval_set_isref_p(pz)
#define Z_UNSET_ISREF_P(pz) zval_unset_isref_p(pz)
#define Z_SET_ISREF_TO_P(pz, isref) zval_set_isref_to_p(pz, isref)
#define Z_REFCOUNT(z) Z_REFCOUNT_P(&(z))
#define Z_SET_REFCOUNT(z, rc) Z_SET_REFCOUNT_P(&(z), rc)
#define Z_ADDREF(z) Z_ADDREF_P(&(z))
#define Z_DELREF(z) Z_DELREF_P(&(z))
#define Z_ISREF(z) Z_ISREF_P(&(z))
#define Z_SET_ISREF(z) Z_SET_ISREF_P(&(z))
#define Z_UNSET_ISREF(z) Z_UNSET_ISREF_P(&(z))
#define Z_SET_ISREF_TO(z, isref) Z_SET_ISREF_TO_P(&(z), isref)
#if defined(__GNUC__)
#define always_inline inline __attribute__((always_inline))
#elif defined(_MSC_VER)
#define always_inline __forceinline
#else
#define always_inline inline
#endif
static always_inline zend_uint zval_refcount_p(zval* pz) {
return pz->refcount__gc;
}
static always_inline zend_uint zval_set_refcount_p(zval* pz, zend_uint rc) {
return pz->refcount__gc = rc;
}
static always_inline zend_uint zval_addref_p(zval* pz) {
return ++pz->refcount__gc;
}
static always_inline zend_uint zval_delref_p(zval* pz) {
return --pz->refcount__gc;
}
static always_inline zend_bool zval_isref_p(zval* pz) {
return pz->is_ref__gc;
}
static always_inline zend_bool zval_set_isref_p(zval* pz) {
return pz->is_ref__gc = 1;
}
static always_inline zend_bool zval_unset_isref_p(zval* pz) {
return pz->is_ref__gc = 0;
}
static always_inline zend_bool zval_set_isref_to_p(zval* pz, zend_bool isref) {
return pz->is_ref__gc = isref;
}
/* excpt.h on Digital Unix 4.0 defines function_table */ /* excpt.h on Digital Unix 4.0 defines function_table */
#undef function_table #undef function_table
@ -561,14 +626,9 @@ END_EXTERN_C()
#define ZMSG_LOG_SCRIPT_NAME 6L #define ZMSG_LOG_SCRIPT_NAME 6L
#define ZMSG_MEMORY_LEAKS_GRAND_TOTAL 7L #define ZMSG_MEMORY_LEAKS_GRAND_TOTAL 7L
#define ZVAL_ADDREF(pz) (++(pz)->refcount)
#define ZVAL_DELREF(pz) (--(pz)->refcount)
#define ZVAL_REFCOUNT(pz) ((pz)->refcount)
#define INIT_PZVAL(z) \ #define INIT_PZVAL(z) \
(z)->refcount = 1; \ (z)->refcount__gc = 1; \
(z)->is_ref = 0; (z)->is_ref__gc = 0;
#define INIT_ZVAL(z) z = zval_used_for_init; #define INIT_ZVAL(z) z = zval_used_for_init;
@ -580,19 +640,19 @@ END_EXTERN_C()
ALLOC_ZVAL(zv); \ ALLOC_ZVAL(zv); \
INIT_PZVAL(zv); INIT_PZVAL(zv);
#define PZVAL_IS_REF(z) ((z)->is_ref) #define PZVAL_IS_REF(z) Z_ISREF_P(z)
#define SEPARATE_ZVAL(ppzv) \ #define SEPARATE_ZVAL(ppzv) \
{ \ { \
zval *orig_ptr = *(ppzv); \ zval *orig_ptr = *(ppzv); \
\ \
if (orig_ptr->refcount>1) { \ if (Z_REFCOUNT_P(orig_ptr)>1) { \
orig_ptr->refcount--; \ Z_DELREF_P(orig_ptr); \
ALLOC_ZVAL(*(ppzv)); \ ALLOC_ZVAL(*(ppzv)); \
**(ppzv) = *orig_ptr; \ **(ppzv) = *orig_ptr; \
zval_copy_ctor(*(ppzv)); \ zval_copy_ctor(*(ppzv)); \
(*(ppzv))->refcount=1; \ Z_SET_REFCOUNT_PP(ppzv, 1); \
(*(ppzv))->is_ref = 0; \ Z_UNSET_ISREF_PP(ppzv); \
} \ } \
} }
@ -604,14 +664,14 @@ END_EXTERN_C()
#define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv) \ #define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv) \
if (!PZVAL_IS_REF(*ppzv)) { \ if (!PZVAL_IS_REF(*ppzv)) { \
SEPARATE_ZVAL(ppzv); \ SEPARATE_ZVAL(ppzv); \
(*(ppzv))->is_ref = 1; \ Z_SET_ISREF_PP(ppzv); \
} }
#define COPY_PZVAL_TO_ZVAL(zv, pzv) \ #define COPY_PZVAL_TO_ZVAL(zv, pzv) \
(zv) = *(pzv); \ (zv) = *(pzv); \
if ((pzv)->refcount>1) { \ if (Z_REFCOUNT_P(pzv)>1) { \
zval_copy_ctor(&(zv)); \ zval_copy_ctor(&(zv)); \
(pzv)->refcount--; \ Z_DELREF_P(pzv); \
} else { \ } else { \
FREE_ZVAL(pzv); \ FREE_ZVAL(pzv); \
} \ } \
@ -621,15 +681,15 @@ END_EXTERN_C()
int is_ref, refcount; \ int is_ref, refcount; \
\ \
SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest); \ SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest); \
is_ref = (*ppzv_dest)->is_ref; \ is_ref = Z_ISREF_PP(ppzv_dest); \
refcount = (*ppzv_dest)->refcount; \ refcount = Z_REFCOUNT_PP(ppzv_dest); \
zval_dtor(*ppzv_dest); \ zval_dtor(*ppzv_dest); \
**ppzv_dest = *pzv_src; \ **ppzv_dest = *pzv_src; \
if (copy) { \ if (copy) { \
zval_copy_ctor(*ppzv_dest); \ zval_copy_ctor(*ppzv_dest); \
} \ } \
(*ppzv_dest)->is_ref = is_ref; \ Z_SET_ISREF_TO_PP(ppzv_dest, is_ref); \
(*ppzv_dest)->refcount = refcount; \ Z_SET_REFCOUNT_PP(ppzv_dest, refcount); \
} }
#define SEPARATE_ARG_IF_REF(varptr) \ #define SEPARATE_ARG_IF_REF(varptr) \
@ -638,15 +698,15 @@ END_EXTERN_C()
ALLOC_ZVAL(varptr); \ ALLOC_ZVAL(varptr); \
varptr->value = original_var->value; \ varptr->value = original_var->value; \
varptr->type = original_var->type; \ varptr->type = original_var->type; \
varptr->is_ref = 0; \ Z_UNSET_ISREF_P(varptr); \
varptr->refcount = 1; \ Z_SET_REFCOUNT_P(varptr, 1); \
zval_copy_ctor(varptr); \ zval_copy_ctor(varptr); \
} else { \ } else { \
varptr->refcount++; \ Z_ADDREF_P(varptr); \
} }
#define READY_TO_DESTROY(zv) \ #define READY_TO_DESTROY(zv) \
((zv)->refcount == 1 && \ (Z_REFCOUNT_P(zv) == 1 && \
(Z_TYPE_P(zv) != IS_OBJECT || \ (Z_TYPE_P(zv) != IS_OBJECT || \
zend_objects_store_get_refcount(zv TSRMLS_CC) == 1)) zend_objects_store_get_refcount(zv TSRMLS_CC) == 1))

74
Zend/zend_API.c
View file

@ -55,7 +55,7 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...)
while (param_count-->0) { while (param_count-->0) {
param = va_arg(ptr, zval **); param = va_arg(ptr, zval **);
param_ptr = *(p-arg_count); param_ptr = *(p-arg_count);
if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) { if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr)>1) {
zval *new_tmp; zval *new_tmp;
ALLOC_ZVAL(new_tmp); ALLOC_ZVAL(new_tmp);
@ -63,7 +63,7 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...)
zval_copy_ctor(new_tmp); zval_copy_ctor(new_tmp);
INIT_PZVAL(new_tmp); INIT_PZVAL(new_tmp);
param_ptr = new_tmp; param_ptr = new_tmp;
((zval *) *(p-arg_count))->refcount--; Z_DELREF_P((zval *) *(p-arg_count));
*(p-arg_count) = param_ptr; *(p-arg_count) = param_ptr;
} }
*param = param_ptr; *param = param_ptr;
@ -90,7 +90,7 @@ ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument
while (param_count-->0) { while (param_count-->0) {
param_ptr = *(p-arg_count); param_ptr = *(p-arg_count);
if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) { if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr)>1) {
zval *new_tmp; zval *new_tmp;
ALLOC_ZVAL(new_tmp); ALLOC_ZVAL(new_tmp);
@ -98,7 +98,7 @@ ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument
zval_copy_ctor(new_tmp); zval_copy_ctor(new_tmp);
INIT_PZVAL(new_tmp); INIT_PZVAL(new_tmp);
param_ptr = new_tmp; param_ptr = new_tmp;
((zval *) *(p-arg_count))->refcount--; Z_DELREF_P((zval *) *(p-arg_count));
*(p-arg_count) = param_ptr; *(p-arg_count) = param_ptr;
} }
*(argument_array++) = param_ptr; *(argument_array++) = param_ptr;
@ -156,7 +156,7 @@ ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_arr
if (EG(ze1_compatibility_mode) && if (EG(ze1_compatibility_mode) &&
Z_TYPE_PP(value) == IS_OBJECT && Z_TYPE_PP(value) == IS_OBJECT &&
!(*value)->is_ref) { !Z_ISREF_PP(value)) {
zval *value_ptr; zval *value_ptr;
char *class_name; char *class_name;
zend_uint class_name_len; zend_uint class_name_len;
@ -291,7 +291,7 @@ static int parse_arg_object_to_string(zval **arg, char **p, int *pl, int type TS
if (!Z_OBJ_HANDLER_PP(arg, cast_object) && Z_OBJ_HANDLER_PP(arg, get)) { if (!Z_OBJ_HANDLER_PP(arg, cast_object) && Z_OBJ_HANDLER_PP(arg, get)) {
int use_copy; int use_copy;
zval *z = Z_OBJ_HANDLER_PP(arg, get)(*arg TSRMLS_CC); zval *z = Z_OBJ_HANDLER_PP(arg, get)(*arg TSRMLS_CC);
z->refcount++; Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) { if(Z_TYPE_P(z) != IS_OBJECT) {
zval_dtor(*arg); zval_dtor(*arg);
Z_TYPE_P(*arg) = IS_NULL; Z_TYPE_P(*arg) = IS_NULL;
@ -894,13 +894,13 @@ ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC
zval **q; zval **q;
zend_hash_get_current_key_ex(&class_type->default_static_members, &str_index, &str_length, &num_index, 0, &pos); zend_hash_get_current_key_ex(&class_type->default_static_members, &str_index, &str_length, &num_index, 0, &pos);
if ((*p)->is_ref && if (Z_ISREF_PP(p) &&
class_type->parent && class_type->parent &&
zend_hash_find(&class_type->parent->default_static_members, str_index, str_length, (void**)&q) == SUCCESS && zend_hash_find(&class_type->parent->default_static_members, str_index, str_length, (void**)&q) == SUCCESS &&
*p == *q && *p == *q &&
zend_hash_find(CE_STATIC_MEMBERS(class_type->parent), str_index, str_length, (void**)&q) == SUCCESS) { zend_hash_find(CE_STATIC_MEMBERS(class_type->parent), str_index, str_length, (void**)&q) == SUCCESS) {
(*q)->refcount++; Z_ADDREF_PP(q);
(*q)->is_ref = 1; Z_SET_ISREF_PP(q);
zend_hash_add(CE_STATIC_MEMBERS(class_type), str_index, str_length, (void**)q, sizeof(zval*), NULL); zend_hash_add(CE_STATIC_MEMBERS(class_type), str_index, str_length, (void**)q, sizeof(zval*), NULL);
} else { } else {
zval *q; zval *q;
@ -2082,7 +2082,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
if (num_symbol_tables <= 0) return FAILURE; if (num_symbol_tables <= 0) return FAILURE;
symbol->is_ref = is_ref; Z_SET_ISREF_TO_P(symbol, is_ref);
va_start(symbol_table_list, num_symbol_tables); va_start(symbol_table_list, num_symbol_tables);
while (num_symbol_tables-- > 0) { while (num_symbol_tables-- > 0) {
@ -2507,7 +2507,7 @@ ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos); zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void **) &arg, &pos) == SUCCESS) { while (zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void **) &arg, &pos) == SUCCESS) {
*params++ = arg; *params++ = arg;
(*arg)->refcount++; Z_ADDREF_PP(arg);
zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos); zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos);
} }
return SUCCESS; return SUCCESS;
@ -2826,8 +2826,8 @@ ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, c
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_NULL(tmp); ZVAL_NULL(tmp);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2837,8 +2837,8 @@ ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, c
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_BOOL(tmp, value); ZVAL_BOOL(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2848,8 +2848,8 @@ ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, c
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_LONG(tmp, value); ZVAL_LONG(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2859,8 +2859,8 @@ ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object,
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_DOUBLE(tmp, value); ZVAL_DOUBLE(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2870,8 +2870,8 @@ ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object,
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRING(tmp, value, 1); ZVAL_STRING(tmp, value, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2881,8 +2881,8 @@ ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRINGL(tmp, value, value_len, 1); ZVAL_STRINGL(tmp, value, value_len, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
} }
@ -2903,13 +2903,13 @@ ZEND_API int zend_update_static_property(zend_class_entry *scope, char *name, in
zval_dtor(*property); zval_dtor(*property);
Z_TYPE_PP(property) = Z_TYPE_P(value); Z_TYPE_PP(property) = Z_TYPE_P(value);
(*property)->value = value->value; (*property)->value = value->value;
if (value->refcount > 0) { if (Z_REFCOUNT_P(value) > 0) {
zval_copy_ctor(*property); zval_copy_ctor(*property);
} }
} else { } else {
zval *garbage = *property; zval *garbage = *property;
value->refcount++; Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) { if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value); SEPARATE_ZVAL(&value);
} }
@ -2926,8 +2926,8 @@ ZEND_API int zend_update_static_property_null(zend_class_entry *scope, char *nam
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_NULL(tmp); ZVAL_NULL(tmp);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }
@ -2937,8 +2937,8 @@ ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, char *nam
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_BOOL(tmp, value); ZVAL_BOOL(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }
@ -2948,8 +2948,8 @@ ZEND_API int zend_update_static_property_long(zend_class_entry *scope, char *nam
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_LONG(tmp, value); ZVAL_LONG(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }
@ -2959,8 +2959,8 @@ ZEND_API int zend_update_static_property_double(zend_class_entry *scope, char *n
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_DOUBLE(tmp, value); ZVAL_DOUBLE(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }
@ -2970,8 +2970,8 @@ ZEND_API int zend_update_static_property_string(zend_class_entry *scope, char *n
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRING(tmp, value, 1); ZVAL_STRING(tmp, value, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }
@ -2981,8 +2981,8 @@ ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, char *
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
tmp->refcount = 0; Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRINGL(tmp, value, value_len, 1); ZVAL_STRINGL(tmp, value, value_len, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC); return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
} }

18
Zend/zend_API.h
View file

@ -485,8 +485,8 @@ END_EXTERN_C()
#define ZVAL_ZVAL(z, zv, copy, dtor) { \ #define ZVAL_ZVAL(z, zv, copy, dtor) { \
int is_ref, refcount; \ int is_ref, refcount; \
is_ref = (z)->is_ref; \ is_ref = Z_ISREF_P(z); \
refcount = (z)->refcount; \ refcount = Z_REFCOUNT_P(z); \
*(z) = *(zv); \ *(z) = *(zv); \
if (copy) { \ if (copy) { \
zval_copy_ctor(z); \ zval_copy_ctor(z); \
@ -497,8 +497,8 @@ END_EXTERN_C()
} \ } \
zval_ptr_dtor(&zv); \ zval_ptr_dtor(&zv); \
} \ } \
(z)->is_ref = is_ref; \ Z_SET_ISREF_TO_P(z, is_ref); \
(z)->refcount = refcount; \ Z_SET_REFCOUNT_P(z, refcount); \
} }
#define ZVAL_FALSE(z) ZVAL_BOOL(z, 0) #define ZVAL_FALSE(z) ZVAL_BOOL(z, 0)
@ -578,19 +578,19 @@ END_EXTERN_C()
\ \
if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \ if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \
&& PZVAL_IS_REF(*orig_var)) { \ && PZVAL_IS_REF(*orig_var)) { \
(var)->refcount = (*orig_var)->refcount; \ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var)); \
(var)->is_ref = 1; \ Z_SET_ISREF_P(var); \
\ \
if (_refcount) { \ if (_refcount) { \
(var)->refcount += _refcount-1; \ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount-1); \
} \ } \
zval_dtor(*orig_var); \ zval_dtor(*orig_var); \
**orig_var = *(var); \ **orig_var = *(var); \
FREE_ZVAL(var); \ FREE_ZVAL(var); \
} else { \ } else { \
(var)->is_ref = _is_ref; \ Z_SET_ISREF_TO_P(var, _is_ref); \
if (_refcount) { \ if (_refcount) { \
(var)->refcount = _refcount; \ Z_SET_REFCOUNT_P(var, _refcount); \
} \ } \
zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL); \ zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL); \
} \ } \

18
Zend/zend_builtin_functions.c
View file

@ -395,18 +395,18 @@ ZEND_FUNCTION(each)
entry = *entry_ptr; entry = *entry_ptr;
/* add value elements */ /* add value elements */
if (entry->is_ref) { if (Z_ISREF_P(entry)) {
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
*tmp = *entry; *tmp = *entry;
zval_copy_ctor(tmp); zval_copy_ctor(tmp);
tmp->is_ref=0; Z_UNSET_ISREF_P(tmp);
tmp->refcount=0; Z_SET_REFCOUNT_P(tmp, 0);
entry=tmp; entry=tmp;
} }
zend_hash_index_update(return_value->value.ht, 1, &entry, sizeof(zval *), NULL); zend_hash_index_update(return_value->value.ht, 1, &entry, sizeof(zval *), NULL);
entry->refcount++; Z_ADDREF_P(entry);
zend_hash_update(return_value->value.ht, "value", sizeof("value"), &entry, sizeof(zval *), NULL); zend_hash_update(return_value->value.ht, "value", sizeof("value"), &entry, sizeof(zval *), NULL);
entry->refcount++; Z_ADDREF_P(entry);
/* add the key elements */ /* add the key elements */
switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_key_len, &num_key, 1, NULL)) { switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_key_len, &num_key, 1, NULL)) {
@ -418,7 +418,7 @@ ZEND_FUNCTION(each)
break; break;
} }
zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL); zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
(*inserted_pointer)->refcount++; Z_ADDREF_PP(inserted_pointer);
zend_hash_move_forward(target_hash); zend_hash_move_forward(target_hash);
} }
/* }}} */ /* }}} */
@ -841,7 +841,7 @@ ZEND_FUNCTION(get_object_vars)
if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) { if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name); zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
/* Not separating references */ /* Not separating references */
(*value)->refcount++; Z_ADDREF_PP(value);
add_assoc_zval_ex(return_value, prop_name, strlen(prop_name)+1, *value); add_assoc_zval_ex(return_value, prop_name, strlen(prop_name)+1, *value);
} }
} }
@ -1700,7 +1700,7 @@ static zval *debug_backtrace_get_args(void ***curpos TSRMLS_DC)
if (Z_TYPE_PP(arg) != IS_OBJECT) { if (Z_TYPE_PP(arg) != IS_OBJECT) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(arg); SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
} }
(*arg)->refcount++; Z_ADDREF_PP(arg);
add_next_index_zval(arg_array, *arg); add_next_index_zval(arg_array, *arg);
} else { } else {
add_next_index_null(arg_array); add_next_index_null(arg_array);
@ -2038,7 +2038,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
} }
if (provide_object) { if (provide_object) {
add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object); add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object);
ptr->object->refcount++; Z_ADDREF_P(ptr->object);
} }
add_assoc_string_ex(stack_frame, "type", sizeof("type"), "->", 1); add_assoc_string_ex(stack_frame, "type", sizeof("type"), "->", 1);

12
Zend/zend_compile.c
View file

@ -94,7 +94,7 @@ static void build_runtime_defined_function_key(zval *result, char *name, int nam
zend_spprintf(&result->value.str.val, 0, "%c%s%s%s", '\0', name, filename, char_pos_buf); zend_spprintf(&result->value.str.val, 0, "%c%s%s%s", '\0', name, filename, char_pos_buf);
#endif /* ZEND_MULTIBYTE */ #endif /* ZEND_MULTIBYTE */
result->type = IS_STRING; result->type = IS_STRING;
result->refcount = 1; Z_SET_REFCOUNT_P(result, 1);
} }
@ -1197,7 +1197,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
opline->op2.u.constant.type = IS_STRING; opline->op2.u.constant.type = IS_STRING;
opline->op2.u.constant.value.str.val = lcname; opline->op2.u.constant.value.str.val = lcname;
opline->op2.u.constant.value.str.len = name_len; opline->op2.u.constant.value.str.len = name_len;
opline->op2.u.constant.refcount = 1; Z_SET_REFCOUNT(opline->op2.u.constant, 1);
opline->extended_value = ZEND_DECLARE_FUNCTION; opline->extended_value = ZEND_DECLARE_FUNCTION;
zend_hash_update(CG(function_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)); zend_hash_update(CG(function_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
} }
@ -2316,7 +2316,7 @@ static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_pro
zval **pvalue; zval **pvalue;
if (zend_hash_quick_find(&parent_ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, (void **) &pvalue) == SUCCESS) { if (zend_hash_quick_find(&parent_ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, (void **) &pvalue) == SUCCESS) {
(*pvalue)->refcount++; Z_ADDREF_PP(pvalue);
zend_hash_del(&ce->default_properties, child_info->name, child_info->name_length+1); zend_hash_del(&ce->default_properties, child_info->name, child_info->name_length+1);
zend_hash_quick_update(&ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, pvalue, sizeof(zval *), NULL); zend_hash_quick_update(&ce->default_properties, parent_info->name, parent_info->name_length+1, parent_info->h, pvalue, sizeof(zval *), NULL);
} }
@ -2350,7 +2350,7 @@ static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_pro
parent_ce->name, prop_name, ce->name); parent_ce->name, prop_name, ce->name);
} }
} }
(*prop)->refcount++; Z_ADDREF_PP(prop);
zend_hash_update(&ce->default_static_members, child_info->name, child_info->name_length+1, (void**)prop, sizeof(zval*), NULL); zend_hash_update(&ce->default_static_members, child_info->name, child_info->name_length+1, (void**)prop, sizeof(zval*), NULL);
zend_hash_del(&ce->default_static_members, prot_name, prot_name_length+1); zend_hash_del(&ce->default_static_members, prot_name, prot_name_length+1);
} }
@ -2421,7 +2421,7 @@ static int inherit_static_prop(zval **p, int num_args, va_list args, zend_hash_k
if (!zend_hash_quick_exists(target, key->arKey, key->nKeyLength, key->h)) { if (!zend_hash_quick_exists(target, key->arKey, key->nKeyLength, key->h)) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(p); SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, p, sizeof(zval*), NULL) == SUCCESS) { if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, p, sizeof(zval*), NULL) == SUCCESS) {
(*p)->refcount++; Z_ADDREF_PP(p);
} }
} }
return ZEND_HASH_APPLY_KEEP; return ZEND_HASH_APPLY_KEEP;
@ -3031,7 +3031,7 @@ void zend_do_begin_class_declaration(znode *class_token, znode *class_name, znod
opline->op2.op_type = IS_CONST; opline->op2.op_type = IS_CONST;
opline->op2.u.constant.type = IS_STRING; opline->op2.u.constant.type = IS_STRING;
opline->op2.u.constant.refcount = 1; Z_SET_REFCOUNT(opline->op2.u.constant, 1);
if (doing_inheritance) { if (doing_inheritance) {
opline->extended_value = parent_class_name->u.var; opline->extended_value = parent_class_name->u.var;

8
Zend/zend_constants.c
View file

@ -257,8 +257,8 @@ ZEND_API int zend_get_constant(char *name, uint name_len, zval *result TSRMLS_DC
if (retval) { if (retval) {
*result = c->value; *result = c->value;
zval_copy_ctor(result); zval_copy_ctor(result);
result->refcount = 1; Z_SET_REFCOUNT_P(result, 1);
result->is_ref = 0; Z_UNSET_ISREF_P(result);
} }
return retval; return retval;
@ -349,8 +349,8 @@ ZEND_API int zend_get_constant_ex(char *name, uint name_len, zval *result, zend_
*result = c->value; *result = c->value;
zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC); zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC);
zval_copy_ctor(result); zval_copy_ctor(result);
result->refcount = 1; Z_SET_REFCOUNT_P(result, 1);
result->is_ref = 0; Z_UNSET_ISREF_P(result);
return 1; return 1;
} }
efree(lcname); efree(lcname);

4
Zend/zend_exceptions.c
View file

@ -87,8 +87,8 @@ static zend_object_value zend_default_exception_new_ex(zend_class_entry *class_t
zend_hash_copy(object->properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *)); zend_hash_copy(object->properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
ALLOC_ZVAL(trace); ALLOC_ZVAL(trace);
trace->is_ref = 0; Z_UNSET_ISREF_P(trace);
trace->refcount = 0; Z_SET_REFCOUNT_P(trace, 0);
zend_fetch_debug_backtrace(trace, skip_top_traces, 0 TSRMLS_CC); zend_fetch_debug_backtrace(trace, skip_top_traces, 0 TSRMLS_CC);
zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC); zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC);

138
Zend/zend_execute.c
View file

@ -66,22 +66,22 @@ static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_
static inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref) static inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref)
{ {
if (!--z->refcount) { if (!Z_DELREF_P(z)) {
z->refcount = 1; Z_SET_REFCOUNT_P(z, 1);
z->is_ref = 0; Z_UNSET_ISREF_P(z);
should_free->var = z; should_free->var = z;
/* should_free->is_var = 1; */ /* should_free->is_var = 1; */
} else { } else {
should_free->var = 0; should_free->var = 0;
if (unref && z->is_ref && z->refcount == 1) { if (unref && Z_ISREF_P(z) && Z_REFCOUNT_P(z) == 1) {
z->is_ref = 0; Z_UNSET_ISREF_P(z);
} }
} }
} }
static inline void zend_pzval_unlock_free_func(zval *z) static inline void zend_pzval_unlock_free_func(zval *z)
{ {
if (!--z->refcount) { if (!Z_DELREF_P(z)) {
zval_dtor(z); zval_dtor(z);
safe_free_zval_ptr(z); safe_free_zval_ptr(z);
} }
@ -90,7 +90,7 @@ static inline void zend_pzval_unlock_free_func(zval *z)
#define PZVAL_UNLOCK(z, f) zend_pzval_unlock_func(z, f, 1) #define PZVAL_UNLOCK(z, f) zend_pzval_unlock_func(z, f, 1)
#define PZVAL_UNLOCK_EX(z, f, u) zend_pzval_unlock_func(z, f, u) #define PZVAL_UNLOCK_EX(z, f, u) zend_pzval_unlock_func(z, f, u)
#define PZVAL_UNLOCK_FREE(z) zend_pzval_unlock_free_func(z) #define PZVAL_UNLOCK_FREE(z) zend_pzval_unlock_free_func(z)
#define PZVAL_LOCK(z) (z)->refcount++ #define PZVAL_LOCK(z) Z_ADDREF_P((z))
#define RETURN_VALUE_UNUSED(pzn) (((pzn)->u.EA.type & EXT_TYPE_UNUSED)) #define RETURN_VALUE_UNUSED(pzn) (((pzn)->u.EA.type & EXT_TYPE_UNUSED))
#define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!RETURN_VALUE_UNUSED(pzn)) { PZVAL_LOCK(pzv); } #define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!RETURN_VALUE_UNUSED(pzn)) { PZVAL_LOCK(pzv); }
@ -128,8 +128,8 @@ static inline void zend_pzval_unlock_free_func(zval *z)
#define INIT_PZVAL_COPY(z,v) \ #define INIT_PZVAL_COPY(z,v) \
(z)->value = (v)->value; \ (z)->value = (v)->value; \
Z_TYPE_P(z) = Z_TYPE_P(v); \ Z_TYPE_P(z) = Z_TYPE_P(v); \
(z)->refcount = 1; \ Z_SET_REFCOUNT_P(z, 1); \
(z)->is_ref = 0; Z_UNSET_ISREF_P(z);
#define MAKE_REAL_ZVAL_PTR(val) \ #define MAKE_REAL_ZVAL_PTR(val) \
do { \ do { \
@ -137,8 +137,8 @@ static inline void zend_pzval_unlock_free_func(zval *z)
ALLOC_ZVAL(_tmp); \ ALLOC_ZVAL(_tmp); \
_tmp->value = (val)->value; \ _tmp->value = (val)->value; \
Z_TYPE_P(_tmp) = Z_TYPE_P(val); \ Z_TYPE_P(_tmp) = Z_TYPE_P(val); \
_tmp->refcount = 1; \ Z_SET_REFCOUNT_P(_tmp, 1); \
_tmp->is_ref = 0; \ Z_UNSET_ISREF_P(_tmp); \
val = _tmp; \ val = _tmp; \
} while (0) } while (0)
@ -167,7 +167,7 @@ static inline void zend_get_cv_address(zend_compiled_variable *cv, zval ***ptr,
{ {
zval *new_zval = &EG(uninitialized_zval); zval *new_zval = &EG(uninitialized_zval);
new_zval->refcount++; Z_ADDREF_P(new_zval);
zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr); zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr);
} }
@ -204,8 +204,8 @@ static inline zval *_get_zval_ptr_var(znode *node, temp_variable *Ts, zend_free_
ptr->value.str.len = 1; ptr->value.str.len = 1;
} }
PZVAL_UNLOCK_FREE(str); PZVAL_UNLOCK_FREE(str);
ptr->refcount=1; Z_SET_REFCOUNT_P(ptr, 1);
ptr->is_ref=1; Z_SET_ISREF_P(ptr);
ptr->type = IS_STRING; ptr->type = IS_STRING;
return ptr; return ptr;
} }
@ -409,35 +409,35 @@ static void zend_assign_to_variable_reference(zval **variable_ptr_ptr, zval **va
} else if (variable_ptr != value_ptr) { } else if (variable_ptr != value_ptr) {
if (!PZVAL_IS_REF(value_ptr)) { if (!PZVAL_IS_REF(value_ptr)) {
/* break it away */ /* break it away */
value_ptr->refcount--; Z_DELREF_P(value_ptr);
if (value_ptr->refcount>0) { if (Z_REFCOUNT_P(value_ptr)>0) {
ALLOC_ZVAL(*value_ptr_ptr); ALLOC_ZVAL(*value_ptr_ptr);
**value_ptr_ptr = *value_ptr; **value_ptr_ptr = *value_ptr;
value_ptr = *value_ptr_ptr; value_ptr = *value_ptr_ptr;
zendi_zval_copy_ctor(*value_ptr); zendi_zval_copy_ctor(*value_ptr);
} }
value_ptr->refcount = 1; Z_SET_REFCOUNT_P(value_ptr, 1);
value_ptr->is_ref = 1; Z_SET_ISREF_P(value_ptr);
} }
*variable_ptr_ptr = value_ptr; *variable_ptr_ptr = value_ptr;
value_ptr->refcount++; Z_ADDREF_P(value_ptr);
zval_ptr_dtor(&variable_ptr); zval_ptr_dtor(&variable_ptr);
} else if (!variable_ptr->is_ref) { } else if (!Z_ISREF_P(variable_ptr)) {
if (variable_ptr_ptr == value_ptr_ptr) { if (variable_ptr_ptr == value_ptr_ptr) {
SEPARATE_ZVAL(variable_ptr_ptr); SEPARATE_ZVAL(variable_ptr_ptr);
} else if (variable_ptr==EG(uninitialized_zval_ptr) } else if (variable_ptr==EG(uninitialized_zval_ptr)
|| variable_ptr->refcount>2) { || Z_REFCOUNT_P(variable_ptr)>2) {
/* we need to separate */ /* we need to separate */
variable_ptr->refcount -= 2; Z_SET_REFCOUNT_P(variable_ptr, Z_REFCOUNT_P(variable_ptr) - 2);
ALLOC_ZVAL(*variable_ptr_ptr); ALLOC_ZVAL(*variable_ptr_ptr);
**variable_ptr_ptr = *variable_ptr; **variable_ptr_ptr = *variable_ptr;
zval_copy_ctor(*variable_ptr_ptr); zval_copy_ctor(*variable_ptr_ptr);
*value_ptr_ptr = *variable_ptr_ptr; *value_ptr_ptr = *variable_ptr_ptr;
(*variable_ptr_ptr)->refcount = 2; Z_SET_REFCOUNT_PP(variable_ptr_ptr, 2);
} }
(*variable_ptr_ptr)->is_ref = 1; Z_SET_ISREF_PP(variable_ptr_ptr);
} }
} }
@ -579,8 +579,8 @@ static inline void zend_assign_to_object(znode *result, zval **object_ptr, znode
ALLOC_ZVAL(value); ALLOC_ZVAL(value);
*value = *orig_value; *value = *orig_value;
value->is_ref = 0; Z_UNSET_ISREF_P(value);
value->refcount = 0; Z_SET_REFCOUNT_P(value, 0);
dup = zend_get_object_classname(orig_value, &class_name, &class_name_len TSRMLS_CC); dup = zend_get_object_classname(orig_value, &class_name, &class_name_len TSRMLS_CC);
if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) { if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) {
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name); zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
@ -595,20 +595,20 @@ static inline void zend_assign_to_object(znode *result, zval **object_ptr, znode
ALLOC_ZVAL(value); ALLOC_ZVAL(value);
*value = *orig_value; *value = *orig_value;
value->is_ref = 0; Z_UNSET_ISREF_P(value);
value->refcount = 0; Z_SET_REFCOUNT_P(value, 0);
} else if (value_op->op_type == IS_CONST) { } else if (value_op->op_type == IS_CONST) {
zval *orig_value = value; zval *orig_value = value;
ALLOC_ZVAL(value); ALLOC_ZVAL(value);
*value = *orig_value; *value = *orig_value;
value->is_ref = 0; Z_UNSET_ISREF_P(value);
value->refcount = 0; Z_SET_REFCOUNT_P(value, 0);
zval_copy_ctor(value); zval_copy_ctor(value);
} }
value->refcount++; Z_ADDREF_P(value);
if (opcode == ZEND_ASSIGN_OBJ) { if (opcode == ZEND_ASSIGN_OBJ) {
if (IS_TMP_FREE(free_op2)) { if (IS_TMP_FREE(free_op2)) {
MAKE_REAL_ZVAL_PTR(property_name); MAKE_REAL_ZVAL_PTR(property_name);
@ -744,28 +744,28 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name); zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
} else if (PZVAL_IS_REF(variable_ptr)) { } else if (PZVAL_IS_REF(variable_ptr)) {
if (variable_ptr != value) { if (variable_ptr != value) {
zend_uint refcount = variable_ptr->refcount; zend_uint refcount = Z_REFCOUNT_P(variable_ptr);
zval garbage; zval garbage;
if (type != IS_TMP_VAR) { if (type != IS_TMP_VAR) {
value->refcount++; Z_ADDREF_P(value);
} }
garbage = *variable_ptr; garbage = *variable_ptr;
*variable_ptr = *value; *variable_ptr = *value;
variable_ptr->refcount = refcount; Z_SET_REFCOUNT_P(variable_ptr, refcount);
variable_ptr->is_ref = 1; Z_SET_ISREF_P(variable_ptr);
zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name); zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
variable_ptr->value.obj = Z_OBJ_HANDLER_P(value, clone_obj)(value TSRMLS_CC); variable_ptr->value.obj = Z_OBJ_HANDLER_P(value, clone_obj)(value TSRMLS_CC);
if (type != IS_TMP_VAR) { if (type != IS_TMP_VAR) {
value->refcount--; Z_DELREF_P(value);
} }
zendi_zval_dtor(garbage); zendi_zval_dtor(garbage);
} }
} else { } else {
if (variable_ptr != value) { if (variable_ptr != value) {
value->refcount++; Z_ADDREF_P(value);
variable_ptr->refcount--; Z_DELREF_P(variable_ptr);
if (variable_ptr->refcount == 0) { if (Z_REFCOUNT_P(variable_ptr) == 0) {
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
} else { } else {
ALLOC_ZVAL(variable_ptr); ALLOC_ZVAL(variable_ptr);
@ -783,42 +783,42 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
} }
} else if (PZVAL_IS_REF(variable_ptr)) { } else if (PZVAL_IS_REF(variable_ptr)) {
if (variable_ptr!=value) { if (variable_ptr!=value) {
zend_uint refcount = variable_ptr->refcount; zend_uint refcount = Z_REFCOUNT_P(variable_ptr);
zval garbage; zval garbage;
if (type!=IS_TMP_VAR) { if (type!=IS_TMP_VAR) {
value->refcount++; Z_ADDREF_P(value);
} }
garbage = *variable_ptr; garbage = *variable_ptr;
*variable_ptr = *value; *variable_ptr = *value;
variable_ptr->refcount = refcount; Z_SET_REFCOUNT_P(variable_ptr, refcount);
variable_ptr->is_ref = 1; Z_SET_ISREF_P(variable_ptr);
if (type!=IS_TMP_VAR) { if (type!=IS_TMP_VAR) {
zendi_zval_copy_ctor(*variable_ptr); zendi_zval_copy_ctor(*variable_ptr);
value->refcount--; Z_DELREF_P(value);
} }
zendi_zval_dtor(garbage); zendi_zval_dtor(garbage);
} }
} else { } else {
variable_ptr->refcount--; Z_DELREF_P(variable_ptr);
if (variable_ptr->refcount==0) { if (Z_REFCOUNT_P(variable_ptr)==0) {
switch (type) { switch (type) {
case IS_CV: case IS_CV:
case IS_VAR: case IS_VAR:
/* break missing intentionally */ /* break missing intentionally */
case IS_CONST: case IS_CONST:
if (variable_ptr==value) { if (variable_ptr==value) {
variable_ptr->refcount++; Z_ADDREF_P(variable_ptr);
} else if (PZVAL_IS_REF(value)) { } else if (PZVAL_IS_REF(value)) {
zval tmp; zval tmp;
tmp = *value; tmp = *value;
zval_copy_ctor(&tmp); zval_copy_ctor(&tmp);
tmp.refcount=1; Z_SET_REFCOUNT(tmp, 1);
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
*variable_ptr = tmp; *variable_ptr = tmp;
} else { } else {
value->refcount++; Z_ADDREF_P(value);
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
safe_free_zval_ptr(variable_ptr); safe_free_zval_ptr(variable_ptr);
*variable_ptr_ptr = value; *variable_ptr_ptr = value;
@ -826,7 +826,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
break; break;
case IS_TMP_VAR: case IS_TMP_VAR:
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
value->refcount=1; Z_SET_REFCOUNT_P(value, 1);
*variable_ptr = *value; *variable_ptr = *value;
break; break;
EMPTY_SWITCH_DEFAULT_CASE() EMPTY_SWITCH_DEFAULT_CASE()
@ -837,26 +837,26 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
case IS_VAR: case IS_VAR:
/* break missing intentionally */ /* break missing intentionally */
case IS_CONST: case IS_CONST:
if (PZVAL_IS_REF(value) && value->refcount > 0) { if (PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) > 0) {
ALLOC_ZVAL(variable_ptr); ALLOC_ZVAL(variable_ptr);
*variable_ptr_ptr = variable_ptr; *variable_ptr_ptr = variable_ptr;
*variable_ptr = *value; *variable_ptr = *value;
zval_copy_ctor(variable_ptr); zval_copy_ctor(variable_ptr);
variable_ptr->refcount=1; Z_SET_REFCOUNT_P(variable_ptr, 1);
break; break;
} }
*variable_ptr_ptr = value; *variable_ptr_ptr = value;
value->refcount++; Z_ADDREF_P(value);
break; break;
case IS_TMP_VAR: case IS_TMP_VAR:
ALLOC_ZVAL(*variable_ptr_ptr); ALLOC_ZVAL(*variable_ptr_ptr);
value->refcount=1; Z_SET_REFCOUNT_P(value, 1);
**variable_ptr_ptr = *value; **variable_ptr_ptr = *value;
break; break;
EMPTY_SWITCH_DEFAULT_CASE() EMPTY_SWITCH_DEFAULT_CASE()
} }
} }
(*variable_ptr_ptr)->is_ref=0; Z_UNSET_ISREF_PP(variable_ptr_ptr);
} }
done_setting_var: done_setting_var:
@ -883,7 +883,7 @@ static inline void zend_receive(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) { if (Z_OBJ_HANDLER_P(value, clone_obj) == NULL) {
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name); zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", class_name);
} else { } else {
variable_ptr->refcount--; Z_DELREF_P(variable_ptr);
ALLOC_ZVAL(variable_ptr); ALLOC_ZVAL(variable_ptr);
*variable_ptr_ptr = variable_ptr; *variable_ptr_ptr = variable_ptr;
*variable_ptr = *value; *variable_ptr = *value;
@ -895,9 +895,9 @@ static inline void zend_receive(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
efree(class_name); efree(class_name);
} }
} else { } else {
variable_ptr->refcount--; Z_DELREF_P(variable_ptr);
*variable_ptr_ptr = value; *variable_ptr_ptr = value;
value->refcount++; Z_ADDREF_P(value);
} }
} }
@ -981,7 +981,7 @@ fetch_string_dim:
case BP_VAR_W: { case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval); zval *new_zval = &EG(uninitialized_zval);
new_zval->refcount++; Z_ADDREF_P(new_zval);
zend_symtable_update(ht, offset_key, offset_key_length+1, &new_zval, sizeof(zval *), (void **) &retval); zend_symtable_update(ht, offset_key, offset_key_length+1, &new_zval, sizeof(zval *), (void **) &retval);
} }
break; break;
@ -1016,7 +1016,7 @@ fetch_string_dim:
case BP_VAR_W: { case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval); zval *new_zval = &EG(uninitialized_zval);
new_zval->refcount++; Z_ADDREF_P(new_zval);
zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval); zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval);
} }
break; break;
@ -1082,18 +1082,18 @@ static void zend_fetch_dimension_address(temp_variable *result, zval **container
zval **retval; zval **retval;
case IS_ARRAY: case IS_ARRAY:
if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) { if ((type==BP_VAR_W || type==BP_VAR_RW) && Z_REFCOUNT_P(container)>1 && !PZVAL_IS_REF(container)) {
SEPARATE_ZVAL(container_ptr); SEPARATE_ZVAL(container_ptr);
container = *container_ptr; container = *container_ptr;
} }
if (dim == NULL) { if (dim == NULL) {
zval *new_zval = &EG(uninitialized_zval); zval *new_zval = &EG(uninitialized_zval);
new_zval->refcount++; Z_ADDREF_P(new_zval);
if (zend_hash_next_index_insert(Z_ARRVAL_P(container), &new_zval, sizeof(zval *), (void **) &retval) == FAILURE) { if (zend_hash_next_index_insert(Z_ARRVAL_P(container), &new_zval, sizeof(zval *), (void **) &retval) == FAILURE) {
zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
retval = &EG(error_zval_ptr); retval = &EG(error_zval_ptr);
new_zval->refcount--; Z_DELREF_P(new_zval);
} }
} else { } else {
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, type TSRMLS_CC); retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, type TSRMLS_CC);
@ -1177,16 +1177,16 @@ static void zend_fetch_dimension_address(temp_variable *result, zval **container
overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC); overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
if (overloaded_result) { if (overloaded_result) {
if (!overloaded_result->is_ref && if (!Z_ISREF_P(overloaded_result) &&
(type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) { (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) {
if (overloaded_result->refcount > 0) { if (Z_REFCOUNT_P(overloaded_result) > 0) {
zval *tmp = overloaded_result; zval *tmp = overloaded_result;
ALLOC_ZVAL(overloaded_result); ALLOC_ZVAL(overloaded_result);
*overloaded_result = *tmp; *overloaded_result = *tmp;
zval_copy_ctor(overloaded_result); zval_copy_ctor(overloaded_result);
overloaded_result->is_ref = 0; Z_UNSET_ISREF_P(overloaded_result);
overloaded_result->refcount = 0; Z_SET_REFCOUNT_P(overloaded_result, 0);
} }
if (Z_TYPE_P(overloaded_result) != IS_OBJECT) { if (Z_TYPE_P(overloaded_result) != IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(container); zend_class_entry *ce = Z_OBJCE_P(container);
@ -1201,9 +1201,9 @@ static void zend_fetch_dimension_address(temp_variable *result, zval **container
result->var.ptr_ptr = retval; result->var.ptr_ptr = retval;
AI_USE_PTR(result->var); AI_USE_PTR(result->var);
PZVAL_LOCK(*result->var.ptr_ptr); PZVAL_LOCK(*result->var.ptr_ptr);
} else if ((*retval)->refcount == 0) { } else if (Z_REFCOUNT_PP(retval) == 0) {
/* Destroy unused result from offsetGet() magic method */ /* Destroy unused result from offsetGet() magic method */
(*retval)->refcount = 1; Z_SET_REFCOUNT_PP(retval, 1);
zval_ptr_dtor(retval); zval_ptr_dtor(retval);
} }
if (dim_is_tmp_var) { if (dim_is_tmp_var) {

64
Zend/zend_execute_API.c
View file

@ -123,7 +123,7 @@ void init_executor(TSRMLS_D)
{ {
INIT_ZVAL(EG(uninitialized_zval)); INIT_ZVAL(EG(uninitialized_zval));
/* trick to make uninitialized_zval never be modified, passed by ref, etc. */ /* trick to make uninitialized_zval never be modified, passed by ref, etc. */
EG(uninitialized_zval).refcount++; Z_ADDREF(EG(uninitialized_zval));
INIT_ZVAL(EG(error_zval)); INIT_ZVAL(EG(error_zval));
EG(uninitialized_zval_ptr)=&EG(uninitialized_zval); EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
EG(error_zval_ptr)=&EG(error_zval); EG(error_zval_ptr)=&EG(error_zval);
@ -153,8 +153,8 @@ void init_executor(TSRMLS_D)
zval *globals; zval *globals;
ALLOC_ZVAL(globals); ALLOC_ZVAL(globals);
globals->refcount=1; Z_SET_REFCOUNT_P(globals, 1);
globals->is_ref=1; Z_SET_ISREF_P(globals);
Z_TYPE_P(globals) = IS_ARRAY; Z_TYPE_P(globals) = IS_ARRAY;
Z_ARRVAL_P(globals) = &EG(symbol_table); Z_ARRVAL_P(globals) = &EG(symbol_table);
zend_hash_update(&EG(symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL);
@ -197,7 +197,7 @@ void init_executor(TSRMLS_D)
static int zval_call_destructor(zval **zv TSRMLS_DC) static int zval_call_destructor(zval **zv TSRMLS_DC)
{ {
if (Z_TYPE_PP(zv) == IS_OBJECT && (*zv)->refcount == 1) { if (Z_TYPE_PP(zv) == IS_OBJECT && Z_REFCOUNT_PP(zv) == 1) {
return ZEND_HASH_APPLY_REMOVE; return ZEND_HASH_APPLY_REMOVE;
} else { } else {
return ZEND_HASH_APPLY_KEEP; return ZEND_HASH_APPLY_KEEP;
@ -408,13 +408,13 @@ ZEND_API zend_bool zend_is_executing(TSRMLS_D)
ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
{ {
#if DEBUG_ZEND>=2 #if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1); printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr)-1);
#endif #endif
(*zval_ptr)->refcount--; Z_DELREF_PP(zval_ptr);
if ((*zval_ptr)->refcount==0) { if (Z_REFCOUNT_PP(zval_ptr)==0) {
zval_dtor(*zval_ptr); zval_dtor(*zval_ptr);
safe_free_zval_ptr_rel(*zval_ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC); safe_free_zval_ptr_rel(*zval_ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC);
} else if ((*zval_ptr)->refcount == 1) { } else if (Z_REFCOUNT_PP(zval_ptr) == 1) {
if ((*zval_ptr)->type == IS_OBJECT) { if ((*zval_ptr)->type == IS_OBJECT) {
TSRMLS_FETCH(); TSRMLS_FETCH();
@ -422,7 +422,7 @@ ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
return; return;
} }
} }
(*zval_ptr)->is_ref = 0; Z_UNSET_ISREF_PP(zval_ptr);
} }
} }
@ -430,14 +430,14 @@ ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
ZEND_API void _zval_internal_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) ZEND_API void _zval_internal_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
{ {
#if DEBUG_ZEND>=2 #if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1); printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr)-1);
#endif #endif
(*zval_ptr)->refcount--; Z_DELREF_PP(zval_ptr);
if ((*zval_ptr)->refcount==0) { if (Z_REFCOUNT_PP(zval_ptr)==0) {
zval_internal_dtor(*zval_ptr); zval_internal_dtor(*zval_ptr);
free(*zval_ptr); free(*zval_ptr);
} else if ((*zval_ptr)->refcount == 1) { } else if (Z_REFCOUNT_PP(zval_ptr) == 1) {
(*zval_ptr)->is_ref = 0; Z_UNSET_ISREF_PP(zval_ptr);
} }
} }
@ -472,8 +472,8 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
MARK_CONSTANT_VISITED(p); MARK_CONSTANT_VISITED(p);
refcount = p->refcount; refcount = Z_REFCOUNT_P(p);
is_ref = p->is_ref; is_ref = Z_ISREF_P(p);
if (!zend_get_constant_ex(p->value.str.val, p->value.str.len, &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) { if (!zend_get_constant_ex(p->value.str.val, p->value.str.len, &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) {
if ((colon = memchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p))) && colon[1] == ':') { if ((colon = memchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p))) && colon[1] == ':') {
@ -493,8 +493,8 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
*p = const_value; *p = const_value;
} }
p->refcount = refcount; Z_SET_REFCOUNT_P(p, refcount);
p->is_ref = is_ref; Z_SET_ISREF_TO_P(p, is_ref);
} else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) { } else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) {
zval **element, *new_val; zval **element, *new_val;
char *str_index; char *str_index;
@ -537,8 +537,8 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
ALLOC_ZVAL(new_val); ALLOC_ZVAL(new_val);
*new_val = **element; *new_val = **element;
zval_copy_ctor(new_val); zval_copy_ctor(new_val);
new_val->refcount = 1; Z_SET_REFCOUNT_P(new_val, 1);
new_val->is_ref = 0; Z_UNSET_ISREF_P(new_val);
/* preserve this bit for inheritance */ /* preserve this bit for inheritance */
Z_TYPE_PP(element) |= IS_CONSTANT_INDEX; Z_TYPE_PP(element) |= IS_CONSTANT_INDEX;
@ -686,7 +686,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
fci->function_name = *tmp_real_function_name; fci->function_name = *tmp_real_function_name;
SEPARATE_ZVAL_IF_NOT_REF(tmp_object_ptr); SEPARATE_ZVAL_IF_NOT_REF(tmp_object_ptr);
fci->object_pp = tmp_object_ptr; fci->object_pp = tmp_object_ptr;
(*fci->object_pp)->is_ref = 1; Z_SET_ISREF_PP(fci->object_pp);
} }
if (fci->object_pp && !*fci->object_pp) { if (fci->object_pp && !*fci->object_pp) {
@ -904,7 +904,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
if (ARG_SHOULD_BE_SENT_BY_REF(EX(function_state).function, i+1) if (ARG_SHOULD_BE_SENT_BY_REF(EX(function_state).function, i+1)
&& !PZVAL_IS_REF(*fci->params[i])) { && !PZVAL_IS_REF(*fci->params[i])) {
if ((*fci->params[i])->refcount>1) { if (Z_REFCOUNT_PP(fci->params[i])>1) {
zval *new_zval; zval *new_zval;
if (fci->no_separation) { if (fci->no_separation) {
@ -923,15 +923,15 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
ALLOC_ZVAL(new_zval); ALLOC_ZVAL(new_zval);
*new_zval = **fci->params[i]; *new_zval = **fci->params[i];
zval_copy_ctor(new_zval); zval_copy_ctor(new_zval);
new_zval->refcount = 1; Z_SET_REFCOUNT_P(new_zval, 1);
(*fci->params[i])->refcount--; Z_DELREF_PP(fci->params[i]);
*fci->params[i] = new_zval; *fci->params[i] = new_zval;
} }
(*fci->params[i])->refcount++; Z_ADDREF_PP(fci->params[i]);
(*fci->params[i])->is_ref = 1; Z_SET_ISREF_PP(fci->params[i]);
param = *fci->params[i]; param = *fci->params[i];
} else if (*fci->params[i] != &EG(uninitialized_zval)) { } else if (*fci->params[i] != &EG(uninitialized_zval)) {
(*fci->params[i])->refcount++; Z_ADDREF_PP(fci->params[i]);
param = *fci->params[i]; param = *fci->params[i];
} else { } else {
ALLOC_ZVAL(param); ALLOC_ZVAL(param);
@ -975,7 +975,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
EG(This) = *fci->object_pp; EG(This) = *fci->object_pp;
if (!PZVAL_IS_REF(EG(This))) { if (!PZVAL_IS_REF(EG(This))) {
EG(This)->refcount++; /* For $this pointer */ Z_ADDREF_P(EG(This)); /* For $this pointer */
} else { } else {
zval *this_ptr; zval *this_ptr;
@ -1278,12 +1278,12 @@ void execute_new_code(TSRMLS_D)
while (opline<end) { while (opline<end) {
if (opline->op1.op_type==IS_CONST) { if (opline->op1.op_type==IS_CONST) {
opline->op1.u.constant.is_ref = 1; Z_SET_ISREF(opline->op1.u.constant);
opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */ Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
} }
if (opline->op2.op_type==IS_CONST) { if (opline->op2.op_type==IS_CONST) {
opline->op2.u.constant.is_ref = 1; Z_SET_ISREF(opline->op2.u.constant);
opline->op2.u.constant.refcount = 2; Z_SET_REFCOUNT(opline->op2.u.constant, 2);
} }
switch (opline->opcode) { switch (opline->opcode) {
case ZEND_JMP: case ZEND_JMP:

2
Zend/zend_interfaces.c
View file

@ -274,7 +274,7 @@ static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zva
iterator = emalloc(sizeof(zend_user_iterator)); iterator = emalloc(sizeof(zend_user_iterator));
object->refcount++; Z_ADDREF_P(object);
iterator->it.data = (void*)object; iterator->it.data = (void*)object;
iterator->it.funcs = ce->iterator_funcs.funcs; iterator->it.funcs = ce->iterator_funcs.funcs;
iterator->ce = Z_OBJCE_P(object); iterator->ce = Z_OBJCE_P(object);

4
Zend/zend_language_scanner.l
View file

@ -378,8 +378,8 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
retval_znode.op_type = IS_CONST; retval_znode.op_type = IS_CONST;
retval_znode.u.constant.type = IS_LONG; retval_znode.u.constant.type = IS_LONG;
retval_znode.u.constant.value.lval = 1; retval_znode.u.constant.value.lval = 1;
retval_znode.u.constant.is_ref = 0; Z_UNSET_ISREF(retval_znode.u.constant);
retval_znode.u.constant.refcount = 1; Z_SET_REFCOUNT(retval_znode.u.constant, 1);
zend_save_lexical_state(&original_lex_state TSRMLS_CC); zend_save_lexical_state(&original_lex_state TSRMLS_CC);

2
Zend/zend_modules.h
View file

@ -39,7 +39,7 @@ extern const struct _zend_arg_info fourth_arg_force_ref[5];
extern const struct _zend_arg_info fifth_arg_force_ref[6]; extern const struct _zend_arg_info fifth_arg_force_ref[6];
extern const struct _zend_arg_info all_args_by_ref[1]; extern const struct _zend_arg_info all_args_by_ref[1];
#define ZEND_MODULE_API_NO 20070929 #define ZEND_MODULE_API_NO 20071006
#ifdef ZTS #ifdef ZTS
#define USING_ZTS 1 #define USING_ZTS 1
#else #else

32
Zend/zend_object_handlers.c
View file

@ -74,7 +74,7 @@ static zval *zend_std_call_getter(zval *object, zval *member TSRMLS_DC)
zval_ptr_dtor(&member); zval_ptr_dtor(&member);
if (retval) { if (retval) {
retval->refcount--; Z_DELREF_P(retval);
} }
return retval; return retval;
@ -87,7 +87,7 @@ static int zend_std_call_setter(zval *object, zval *member, zval *value TSRMLS_D
zend_class_entry *ce = Z_OBJCE_P(object); zend_class_entry *ce = Z_OBJCE_P(object);
SEPARATE_ARG_IF_REF(member); SEPARATE_ARG_IF_REF(member);
value->refcount++; Z_ADDREF_P(value);
/* __set handler is called with two arguments: /* __set handler is called with two arguments:
property name property name
@ -334,16 +334,16 @@ zval *zend_std_read_property(zval *object, zval *member, int type TSRMLS_DC)
if (rv) { if (rv) {
retval = &rv; retval = &rv;
if (!rv->is_ref && if (!Z_ISREF_P(rv) &&
(type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) { (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) {
if (rv->refcount > 0) { if (Z_REFCOUNT_P(rv) > 0) {
zval *tmp = rv; zval *tmp = rv;
ALLOC_ZVAL(rv); ALLOC_ZVAL(rv);
*rv = *tmp; *rv = *tmp;
zval_copy_ctor(rv); zval_copy_ctor(rv);
rv->is_ref = 0; Z_UNSET_ISREF_P(rv);
rv->refcount = 0; Z_SET_REFCOUNT_P(rv, 0);
} }
if (Z_TYPE_P(rv) != IS_OBJECT) { if (Z_TYPE_P(rv) != IS_OBJECT) {
zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", zobj->ce->name, Z_STRVAL_P(member)); zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", zobj->ce->name, Z_STRVAL_P(member));
@ -360,9 +360,9 @@ zval *zend_std_read_property(zval *object, zval *member, int type TSRMLS_DC)
} }
} }
if (tmp_member) { if (tmp_member) {
(*retval)->refcount++; Z_ADDREF_PP(retval);
zval_ptr_dtor(&tmp_member); zval_ptr_dtor(&tmp_member);
(*retval)->refcount--; Z_DELREF_PP(retval);
} }
return *retval; return *retval;
} }
@ -399,7 +399,7 @@ static void zend_std_write_property(zval *object, zval *member, zval *value TSRM
/* To check: can't *variable_ptr be some system variable like error_zval here? */ /* To check: can't *variable_ptr be some system variable like error_zval here? */
(*variable_ptr)->type = value->type; (*variable_ptr)->type = value->type;
(*variable_ptr)->value = value->value; (*variable_ptr)->value = value->value;
if (value->refcount>0) { if (Z_REFCOUNT_P(value)>0) {
zval_copy_ctor(*variable_ptr); zval_copy_ctor(*variable_ptr);
} }
zval_dtor(&garbage); zval_dtor(&garbage);
@ -407,7 +407,7 @@ static void zend_std_write_property(zval *object, zval *member, zval *value TSRM
zval *garbage = *variable_ptr; zval *garbage = *variable_ptr;
/* if we assign referenced variable, we should separate it */ /* if we assign referenced variable, we should separate it */
value->refcount++; Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) { if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value); SEPARATE_ZVAL(&value);
} }
@ -433,7 +433,7 @@ static void zend_std_write_property(zval *object, zval *member, zval *value TSRM
zval **foo; zval **foo;
/* if we assign referenced variable, we should separate it */ /* if we assign referenced variable, we should separate it */
value->refcount++; Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) { if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value); SEPARATE_ZVAL(&value);
} }
@ -470,7 +470,7 @@ zval *zend_std_read_dimension(zval *object, zval *offset, int type TSRMLS_DC)
} }
/* Undo PZVAL_LOCK() */ /* Undo PZVAL_LOCK() */
retval->refcount--; Z_DELREF_P(retval);
return retval; return retval;
} else { } else {
@ -562,7 +562,7 @@ static zval **zend_std_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC
new_zval = &EG(uninitialized_zval); new_zval = &EG(uninitialized_zval);
/* zend_error(E_NOTICE, "Undefined property: %s", Z_STRVAL_P(member)); */ /* zend_error(E_NOTICE, "Undefined property: %s", Z_STRVAL_P(member)); */
new_zval->refcount++; Z_ADDREF_P(new_zval);
zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void **) &retval); zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void **) &retval);
} else { } else {
/* we do have getter - fail and let it try again with usual get/set */ /* we do have getter - fail and let it try again with usual get/set */
@ -657,7 +657,7 @@ ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS)
zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr); zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
if (method_result_ptr) { if (method_result_ptr) {
if (method_result_ptr->is_ref || method_result_ptr->refcount > 1) { if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
RETVAL_ZVAL(method_result_ptr, 1, 1); RETVAL_ZVAL(method_result_ptr, 1, 1);
} else { } else {
RETVAL_ZVAL(method_result_ptr, 0, 1); RETVAL_ZVAL(method_result_ptr, 0, 1);
@ -852,7 +852,7 @@ ZEND_API void zend_std_callstatic_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{
zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr); zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
if (method_result_ptr) { if (method_result_ptr) {
if (method_result_ptr->is_ref || method_result_ptr->refcount > 1) { if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
RETVAL_ZVAL(method_result_ptr, 1, 1); RETVAL_ZVAL(method_result_ptr, 1, 1);
} else { } else {
RETVAL_ZVAL(method_result_ptr, 0, 1); RETVAL_ZVAL(method_result_ptr, 0, 1);
@ -1064,7 +1064,7 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists
rv = zend_std_call_getter(object, member TSRMLS_CC); rv = zend_std_call_getter(object, member TSRMLS_CC);
guard->in_get = 0; guard->in_get = 0;
if (rv) { if (rv) {
rv->refcount++; Z_ADDREF_P(rv);
result = i_zend_is_true(rv); result = i_zend_is_true(rv);
zval_ptr_dtor(&rv); zval_ptr_dtor(&rv);
} }

2
Zend/zend_objects.c
View file

@ -156,7 +156,7 @@ static void zval_add_ref_or_clone(zval **p)
(*p)->value.obj = Z_OBJ_HT_PP(p)->clone_obj(orig TSRMLS_CC); (*p)->value.obj = Z_OBJ_HT_PP(p)->clone_obj(orig TSRMLS_CC);
} }
} else { } else {
(*p)->refcount++; Z_ADDREF_PP(p);
} }
} }

4
Zend/zend_objects_API.c
View file

@ -164,9 +164,9 @@ ZEND_API void zend_objects_store_del_ref(zval *zobject TSRMLS_DC)
handle = Z_OBJ_HANDLE_P(zobject); handle = Z_OBJ_HANDLE_P(zobject);
zobject->refcount++; Z_ADDREF_P(zobject);
zend_objects_store_del_ref_by_handle(handle TSRMLS_CC); zend_objects_store_del_ref_by_handle(handle TSRMLS_CC);
zobject->refcount--; Z_DELREF_P(zobject);
} }
/* /*

8
Zend/zend_opcode.c
View file

@ -378,12 +378,12 @@ int pass_two(zend_op_array *op_array TSRMLS_DC)
end = opline + op_array->last; end = opline + op_array->last;
while (opline < end) { while (opline < end) {
if (opline->op1.op_type == IS_CONST) { if (opline->op1.op_type == IS_CONST) {
opline->op1.u.constant.is_ref = 1; Z_SET_ISREF(opline->op1.u.constant);
opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */ Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
} }
if (opline->op2.op_type == IS_CONST) { if (opline->op2.op_type == IS_CONST) {
opline->op2.u.constant.is_ref = 1; Z_SET_ISREF(opline->op2.u.constant);
opline->op2.u.constant.refcount = 2; Z_SET_REFCOUNT(opline->op2.u.constant, 2);
} }
switch (opline->opcode) { switch (opline->opcode) {
case ZEND_JMP: case ZEND_JMP:

2
Zend/zend_operators.c
View file

@ -1306,7 +1306,7 @@ ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_
static inline void zend_free_obj_get_result(zval *op) static inline void zend_free_obj_get_result(zval *op)
{ {
if (op) { if (op) {
if (op->refcount == 0) { if (Z_REFCOUNT_P(op) == 0) {
zval_dtor(op); zval_dtor(op);
FREE_ZVAL(op); FREE_ZVAL(op);
} else { } else {

2
Zend/zend_operators.h
View file

@ -367,7 +367,7 @@ END_EXTERN_C()
#define convert_scalar_to_number_ex(ppzv) \ #define convert_scalar_to_number_ex(ppzv) \
if (Z_TYPE_PP(ppzv)!=IS_LONG && Z_TYPE_PP(ppzv)!=IS_DOUBLE) { \ if (Z_TYPE_PP(ppzv)!=IS_LONG && Z_TYPE_PP(ppzv)!=IS_DOUBLE) { \
if (!(*ppzv)->is_ref) { \ if (!Z_ISREF_PP(ppzv)) { \
SEPARATE_ZVAL(ppzv); \ SEPARATE_ZVAL(ppzv); \
} \ } \
convert_scalar_to_number(*ppzv TSRMLS_CC); \ convert_scalar_to_number(*ppzv TSRMLS_CC); \

2
Zend/zend_variables.c
View file

@ -97,7 +97,7 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
ZEND_API void zval_add_ref(zval **p) ZEND_API void zval_add_ref(zval **p)
{ {
(*p)->refcount++; Z_ADDREF_PP(p);
} }

130
Zend/zend_vm_def.h
View file

@ -348,13 +348,13 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
if (z->refcount == 0) { if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z); zval_dtor(z);
FREE_ZVAL(z); FREE_ZVAL(z);
} }
z = value; z = value;
} }
z->refcount++; Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z); SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC); binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) { switch (opline->extended_value) {
@ -409,7 +409,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU
zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W); zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
if (object_ptr && OP1_TYPE != IS_CV && !OP1_FREE) { if (object_ptr && OP1_TYPE != IS_CV && !OP1_FREE) {
(*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
} }
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) { if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
@ -456,7 +456,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU
&& Z_OBJ_HANDLER_PP(var_ptr, set)) { && Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */ /* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
objval->refcount++; Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC); binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval); zval_ptr_dtor(&objval);
@ -586,13 +586,13 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
if (z->refcount == 0) { if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z); zval_dtor(z);
FREE_ZVAL(z); FREE_ZVAL(z);
} }
z = value; z = value;
} }
z->refcount++; Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z); SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z); incdec_op(z);
*retval = z; *retval = z;
@ -676,7 +676,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
if (z->refcount == 0) { if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z); zval_dtor(z);
FREE_ZVAL(z); FREE_ZVAL(z);
} }
@ -689,7 +689,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
zendi_zval_copy_ctor(*z_copy); zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy); INIT_PZVAL(z_copy);
incdec_op(z_copy); incdec_op(z_copy);
z->refcount++; Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC); Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy); zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z); zval_ptr_dtor(&z);
@ -743,7 +743,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
&& Z_OBJ_HANDLER_PP(var_ptr, set)) { && Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */ /* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
val->refcount++; Z_ADDREF_P(val);
increment_function(val); increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val); zval_ptr_dtor(&val);
@ -786,7 +786,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
&& Z_OBJ_HANDLER_PP(var_ptr, set)) { && Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */ /* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
val->refcount++; Z_ADDREF_P(val);
decrement_function(val); decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val); zval_ptr_dtor(&val);
@ -830,7 +830,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
&& Z_OBJ_HANDLER_PP(var_ptr, set)) { && Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */ /* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
val->refcount++; Z_ADDREF_P(val);
increment_function(val); increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val); zval_ptr_dtor(&val);
@ -868,7 +868,7 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
&& Z_OBJ_HANDLER_PP(var_ptr, set)) { && Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */ /* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
val->refcount++; Z_ADDREF_P(val);
decrement_function(val); decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val); zval_ptr_dtor(&val);
@ -949,7 +949,7 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type
case BP_VAR_W: { case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval); zval *new_zval = &EG(uninitialized_zval);
new_zval->refcount++; Z_ADDREF_P(new_zval);
zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval); zend_hash_update(target_symbol_table, varname->value.str.val, varname->value.str.len+1, &new_zval, sizeof(zval *), (void **) &retval);
} }
break; break;
@ -1201,7 +1201,7 @@ ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|
/* here we are sure we are dealing with an object */ /* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC); *retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) { if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval); zval_dtor(*retval);
FREE_ZVAL(*retval); FREE_ZVAL(*retval);
} else { } else {
@ -1443,7 +1443,7 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
if (OP2_TYPE == IS_VAR && if (OP2_TYPE == IS_VAR &&
value_ptr_ptr && value_ptr_ptr &&
!(*value_ptr_ptr)->is_ref && !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION && opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) { !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) { if (free_op2.var == NULL) {
@ -1583,9 +1583,9 @@ ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
tmp->value.str.val = emalloc(1); tmp->value.str.val = emalloc(1);
tmp->value.str.val[0] = 0; tmp->value.str.val[0] = 0;
tmp->value.str.len = 0; tmp->value.str.len = 0;
tmp->refcount = 1; Z_SET_REFCOUNT_P(tmp, 1);
tmp->type = IS_STRING; tmp->type = IS_STRING;
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -1716,7 +1716,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
EX(object) = NULL; EX(object) = NULL;
} else { } else {
if (!PZVAL_IS_REF(EX(object))) { if (!PZVAL_IS_REF(EX(object))) {
EX(object)->refcount++; /* For $this pointer */ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else { } else {
zval *this_ptr; zval *this_ptr;
ALLOC_ZVAL(this_ptr); ALLOC_ZVAL(this_ptr);
@ -1813,7 +1813,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
} }
if ((EX(object) = EG(This))) { if ((EX(object) = EG(This))) {
EX(object)->refcount++; Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object)); EX(called_scope) = Z_OBJCE_P(EX(object));
} }
} }
@ -1967,8 +1967,8 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
/* We shouldn't fix bad extensions here, /* We shouldn't fix bad extensions here,
because it can break proper ones (Bug #34045) because it can break proper ones (Bug #34045)
if (!EX(function_state).function->common.return_reference) { if (!EX(function_state).function->common.return_reference) {
EX_T(opline->result.u.var).var.ptr->is_ref = 0; Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
EX_T(opline->result.u.var).var.ptr->refcount = 1; Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
} }
*/ */
if (!return_value_used) { if (!return_value_used) {
@ -2035,8 +2035,8 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
if (!return_value_used) { if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr); zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else { } else {
EX_T(opline->result.u.var).var.ptr->is_ref = 0; Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
EX_T(opline->result.u.var).var.ptr->refcount = 1; Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
EX_T(opline->result.u.var).var.fcall_returned_reference = 0; EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
} }
} }
@ -2044,9 +2044,9 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
if (EG(This)) { if (EG(This)) {
if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) { if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
if (IS_CTOR_USED(EX(called_scope))) { if (IS_CTOR_USED(EX(called_scope))) {
EG(This)->refcount--; Z_DELREF_P(EG(This));
} }
if (EG(This)->refcount == 1) { if (Z_REFCOUNT_P(EG(This)) == 1) {
zend_object_store_ctor_failed(EG(This) TSRMLS_CC); zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
} }
} }
@ -2123,7 +2123,7 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
} }
if (OP1_TYPE == IS_VAR && !(*retval_ptr_ptr)->is_ref) { if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION && if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) { EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) { } else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
@ -2136,7 +2136,7 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
} }
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
(*retval_ptr_ptr)->refcount++; Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr); (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else { } else {
@ -2164,7 +2164,7 @@ ZEND_VM_C_LABEL(return_by_value):
} }
} else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */ } else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF || if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
(PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) { (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret; zval *ret;
ALLOC_ZVAL(ret); ALLOC_ZVAL(ret);
@ -2173,7 +2173,7 @@ ZEND_VM_C_LABEL(return_by_value):
*EG(return_value_ptr_ptr) = ret; *EG(return_value_ptr_ptr) = ret;
} else { } else {
*EG(return_value_ptr_ptr) = retval_ptr; *EG(return_value_ptr_ptr) = retval_ptr;
retval_ptr->refcount++; Z_ADDREF_P(retval_ptr);
} }
} else { } else {
zval *ret; zval *ret;
@ -2274,17 +2274,17 @@ ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
if (varptr == &EG(uninitialized_zval)) { if (varptr == &EG(uninitialized_zval)) {
ALLOC_ZVAL(varptr); ALLOC_ZVAL(varptr);
INIT_ZVAL(*varptr); INIT_ZVAL(*varptr);
varptr->refcount = 0; Z_SET_REFCOUNT_P(varptr, 0);
} else if (PZVAL_IS_REF(varptr)) { } else if (PZVAL_IS_REF(varptr)) {
zval *original_var = varptr; zval *original_var = varptr;
ALLOC_ZVAL(varptr); ALLOC_ZVAL(varptr);
*varptr = *original_var; *varptr = *original_var;
varptr->is_ref = 0; Z_UNSET_ISREF_P(varptr);
varptr->refcount = 0; Z_SET_REFCOUNT_P(varptr, 0);
zval_copy_ctor(varptr); zval_copy_ctor(varptr);
} }
varptr->refcount++; Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr); zend_ptr_stack_push(&EG(argument_stack), varptr);
FREE_OP1(); /* for string offsets */ FREE_OP1(); /* for string offsets */
@ -2318,9 +2318,9 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
EX_T(opline->op1.u.var).var.fcall_returned_reference) && EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
varptr != &EG(uninitialized_zval) && varptr != &EG(uninitialized_zval) &&
(PZVAL_IS_REF(varptr) || (PZVAL_IS_REF(varptr) ||
(varptr->refcount == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) { (Z_REFCOUNT_P(varptr) == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) {
varptr->is_ref = 1; Z_SET_ISREF_P(varptr);
varptr->refcount++; Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr); zend_ptr_stack_push(&EG(argument_stack), varptr);
} else { } else {
zval *valptr; zval *valptr;
@ -2351,7 +2351,7 @@ ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr); SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
varptr = *varptr_ptr; varptr = *varptr_ptr;
varptr->refcount++; Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr); zend_ptr_stack_push(&EG(argument_stack), varptr);
FREE_OP1_VAR_PTR(); FREE_OP1_VAR_PTR();
@ -2421,10 +2421,10 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) { if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
zval_copy_ctor(default_value); zval_copy_ctor(default_value);
} }
default_value->refcount=1; Z_SET_REFCOUNT_P(default_value, 1);
zval_update_constant(&default_value, 0 TSRMLS_CC); zval_update_constant(&default_value, 0 TSRMLS_CC);
default_value->refcount=0; Z_SET_REFCOUNT_P(default_value, 0);
default_value->is_ref=0; Z_UNSET_ISREF_P(default_value);
param = &default_value; param = &default_value;
assignment_value = default_value; assignment_value = default_value;
} else { } else {
@ -2496,7 +2496,7 @@ ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr); PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else { } else {
switch_expr_is_overloaded = 1; switch_expr_is_overloaded = 1;
EX_T(opline->op1.u.var).str_offset.str->refcount++; Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
} }
} }
is_equal_function(&EX_T(opline->result.u.var).tmp_var, is_equal_function(&EX_T(opline->result.u.var).tmp_var,
@ -2581,7 +2581,7 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) { if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object"); zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr); EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
EX_T(opline->result.u.var).var.ptr->refcount++; Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
FREE_OP1_IF_VAR(); FREE_OP1_IF_VAR();
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -2596,7 +2596,7 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
} }
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr); EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
EX_T(opline->result.u.var).var.ptr->refcount++; Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
} }
if (ce && clone) { if (ce && clone) {
@ -2620,8 +2620,8 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr); ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC); Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT; Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
EX_T(opline->result.u.var).var.ptr->refcount=1; Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
EX_T(opline->result.u.var).var.ptr->is_ref=1; Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) { if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr); zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} }
@ -2729,7 +2729,7 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
if (opline->extended_value) { if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr; expr_ptr = *expr_ptr_ptr;
expr_ptr->refcount++; Z_ADDREF_P(expr_ptr);
} else } else
#endif #endif
if (PZVAL_IS_REF(expr_ptr)) { if (PZVAL_IS_REF(expr_ptr)) {
@ -2740,7 +2740,7 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
expr_ptr = new_expr; expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr); zendi_zval_copy_ctor(*expr_ptr);
} else { } else {
expr_ptr->refcount++; Z_ADDREF_P(expr_ptr);
} }
} }
if (offset) { if (offset) {
@ -2992,7 +2992,7 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
convert_to_string(&tmp); convert_to_string(&tmp);
varname = &tmp; varname = &tmp;
} else if (OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) { } else if (OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) {
varname->refcount++; Z_ADDREF_P(varname);
} }
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) { if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
@ -3059,7 +3059,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
break; break;
case IS_STRING: case IS_STRING:
if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) { if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
offset->refcount++; Z_ADDREF_P(offset);
} }
if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS && if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
ht == &EG(symbol_table)) { ht == &EG(symbol_table)) {
@ -3179,18 +3179,18 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
ce = Z_OBJCE_PP(array_ptr_ptr); ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) { if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
(*array_ptr_ptr)->refcount++; Z_ADDREF_PP(array_ptr_ptr);
} }
array_ptr = *array_ptr_ptr; array_ptr = *array_ptr_ptr;
} else { } else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) { if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
(*array_ptr_ptr)->is_ref = 1; Z_SET_ISREF_PP(array_ptr_ptr);
} }
} }
array_ptr = *array_ptr_ptr; array_ptr = *array_ptr_ptr;
array_ptr->refcount++; Z_ADDREF_P(array_ptr);
} }
} else { } else {
array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
@ -3203,12 +3203,12 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr); ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) { if (!ce || !ce->get_iterator) {
array_ptr->refcount++; Z_ADDREF_P(array_ptr);
} }
} else { } else {
if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) && if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
!array_ptr->is_ref && !Z_ISREF_P(array_ptr) &&
array_ptr->refcount > 1) { Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp; zval *tmp;
ALLOC_ZVAL(tmp); ALLOC_ZVAL(tmp);
@ -3216,7 +3216,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
zval_copy_ctor(tmp); zval_copy_ctor(tmp);
array_ptr = tmp; array_ptr = tmp;
} else { } else {
array_ptr->refcount++; Z_ADDREF_P(array_ptr);
} }
} }
} }
@ -3249,7 +3249,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
if (iter->funcs->rewind) { if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC); iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) { if (EG(exception)) {
array_ptr->refcount--; Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr); zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) { if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
FREE_OP1_VAR_PTR(); FREE_OP1_VAR_PTR();
@ -3261,7 +3261,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
} }
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) { if (EG(exception)) {
array_ptr->refcount--; Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr); zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) { if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
FREE_OP1_VAR_PTR(); FREE_OP1_VAR_PTR();
@ -3379,7 +3379,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
* In case that ever happens we need an additional flag. */ * In case that ever happens we need an additional flag. */
iter->funcs->move_forward(iter TSRMLS_CC); iter->funcs->move_forward(iter TSRMLS_CC);
if (EG(exception)) { if (EG(exception)) {
array->refcount--; Z_DELREF_P(array);
zval_ptr_dtor(&array); zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -3388,7 +3388,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) { if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
/* reached end of iteration */ /* reached end of iteration */
if (EG(exception)) { if (EG(exception)) {
array->refcount--; Z_DELREF_P(array);
zval_ptr_dtor(&array); zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -3396,7 +3396,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
} }
iter->funcs->get_current_data(iter, &value TSRMLS_CC); iter->funcs->get_current_data(iter, &value TSRMLS_CC);
if (EG(exception)) { if (EG(exception)) {
array->refcount--; Z_DELREF_P(array);
zval_ptr_dtor(&array); zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -3408,7 +3408,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
if (iter->funcs->get_current_key) { if (iter->funcs->get_current_key) {
key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC); key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
if (EG(exception)) { if (EG(exception)) {
array->refcount--; Z_DELREF_P(array);
zval_ptr_dtor(&array); zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
@ -3422,9 +3422,9 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
if (opline->extended_value & ZEND_FE_FETCH_BYREF) { if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
SEPARATE_ZVAL_IF_NOT_REF(value); SEPARATE_ZVAL_IF_NOT_REF(value);
(*value)->is_ref = 1; Z_SET_ISREF_PP(value);
EX_T(opline->result.u.var).var.ptr_ptr = value; EX_T(opline->result.u.var).var.ptr_ptr = value;
(*value)->refcount++; Z_ADDREF_PP(value);
} else { } else {
EX_T(opline->result.u.var).var.ptr_ptr = value; EX_T(opline->result.u.var).var.ptr_ptr = value;
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr); PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
@ -3855,7 +3855,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack)); EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
if (EX(object)) { if (EX(object)) {
if (IS_CTOR_USED(EX(called_scope))) { if (IS_CTOR_USED(EX(called_scope))) {
EX(object)->refcount--; Z_DELREF_P(EX(object));
} }
zval_ptr_dtor(&EX(object)); zval_ptr_dtor(&EX(object));
} }

684
Zend/zend_vm_execute.h
View file

File diff suppressed because it is too large Load diff

4
Zend/zend_vm_execute.skl
View file

@ -37,9 +37,9 @@ ZEND_API void {%EXECUTOR_NAME%}(zend_op_array *op_array TSRMLS_DC)
} }
if (op_array->uses_this && EG(This)) { if (op_array->uses_this && EG(This)) {
EG(This)->refcount++; /* For $this pointer */ Z_ADDREF_P(EG(This)); /* For $this pointer */
if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) { if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) {
EG(This)->refcount--; Z_DELREF_P(EG(This));
} }
} }

8
ext/com_dotnet/com_handlers.c
View file

@ -38,8 +38,8 @@ static zval *com_property_read(zval *object, zval *member, int type TSRMLS_DC)
MAKE_STD_ZVAL(return_value); MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value); ZVAL_NULL(return_value);
return_value->refcount = 0; Z_SET_REFCOUNT_P(return_value, 0);
return_value->is_ref = 0; Z_UNSET_ISREF_P(return_value);
obj = CDNO_FETCH(object); obj = CDNO_FETCH(object);
@ -92,8 +92,8 @@ static zval *com_read_dimension(zval *object, zval *offset, int type TSRMLS_DC)
MAKE_STD_ZVAL(return_value); MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value); ZVAL_NULL(return_value);
return_value->refcount = 0; Z_SET_REFCOUNT_P(return_value, 0);
return_value->is_ref = 0; Z_UNSET_ISREF_P(return_value);
obj = CDNO_FETCH(object); obj = CDNO_FETCH(object);

6
ext/com_dotnet/com_saproxy.c
View file

@ -427,7 +427,7 @@ static void saproxy_clone(void *object, void **clone_ptr TSRMLS_DC)
cloneproxy = emalloc(sizeof(*cloneproxy)); cloneproxy = emalloc(sizeof(*cloneproxy));
memcpy(cloneproxy, proxy, sizeof(*cloneproxy)); memcpy(cloneproxy, proxy, sizeof(*cloneproxy));
ZVAL_ADDREF(cloneproxy->zobj); Z_ADDREF_P(cloneproxy->zobj);
cloneproxy->indices = safe_emalloc(cloneproxy->dimensions, sizeof(zval *), 0); cloneproxy->indices = safe_emalloc(cloneproxy->dimensions, sizeof(zval *), 0);
clone_indices(cloneproxy, proxy, proxy->dimensions); clone_indices(cloneproxy, proxy, proxy->dimensions);
@ -451,7 +451,7 @@ int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index TSRMLS
proxy->zobj = com_object; proxy->zobj = com_object;
} }
ZVAL_ADDREF(proxy->zobj); Z_ADDREF_P(proxy->zobj);
proxy->indices = safe_emalloc(proxy->dimensions, sizeof(zval *), 0); proxy->indices = safe_emalloc(proxy->dimensions, sizeof(zval *), 0);
if (rel) { if (rel) {
@ -570,7 +570,7 @@ zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *objec
I->proxy = proxy; I->proxy = proxy;
I->proxy_obj = object; I->proxy_obj = object;
ZVAL_ADDREF(I->proxy_obj); Z_ADDREF_P(I->proxy_obj);
I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0); I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0);
for (i = 0; i < proxy->dimensions; i++) { for (i = 0; i < proxy->dimensions; i++) {

2
ext/com_dotnet/com_wrapper.c
View file

@ -551,7 +551,7 @@ static php_dispatchex *disp_constructor(zval *object TSRMLS_DC)
if (object) if (object)
ZVAL_ADDREF(object); Z_ADDREF_P(object);
disp->object = object; disp->object = object;
disp->id = zend_list_insert(disp, le_dispatch); disp->id = zend_list_insert(disp, le_dispatch);

4
ext/date/php_date.c
View file

@ -1627,8 +1627,8 @@ static zval * date_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC)
Z_TYPE_P(object) = IS_OBJECT; Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce); object_init_ex(object, pce);
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 0; Z_UNSET_ISREF_P(object);
return object; return object;
} }

2
ext/dom/attr.c
View file

@ -179,7 +179,7 @@ int dom_attr_value_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;

2
ext/dom/characterdata.c
View file

@ -86,7 +86,7 @@ int dom_characterdata_data_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;

22
ext/dom/document.c
View file

@ -216,7 +216,7 @@ int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -284,7 +284,7 @@ int dom_document_standalone_write(dom_object *obj, zval *newval TSRMLS_DC)
return FAILURE; return FAILURE;
} }
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -359,7 +359,7 @@ int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -402,7 +402,7 @@ int dom_document_strict_error_checking_write(dom_object *obj, zval *newval TSRML
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -445,7 +445,7 @@ int dom_document_format_output_write(dom_object *obj, zval *newval TSRMLS_DC)
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -487,7 +487,7 @@ int dom_document_validate_on_parse_write(dom_object *obj, zval *newval TSRMLS_DC
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -530,7 +530,7 @@ int dom_document_resolve_externals_write(dom_object *obj, zval *newval TSRMLS_DC
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -573,7 +573,7 @@ int dom_document_preserve_whitespace_write(dom_object *obj, zval *newval TSRMLS_
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -615,7 +615,7 @@ int dom_document_recover_write(dom_object *obj, zval *newval TSRMLS_DC)
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -658,7 +658,7 @@ int dom_document_substitue_entities_write(dom_object *obj, zval *newval TSRMLS_D
zval value_copy; zval value_copy;
dom_doc_propsptr doc_prop; dom_doc_propsptr doc_prop;
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -724,7 +724,7 @@ int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;

6
ext/dom/dom_iterators.c
View file

@ -209,7 +209,7 @@ static void php_dom_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
zend_hash_move_forward(nodeht); zend_hash_move_forward(nodeht);
if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) { if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
curattr = *entry; curattr = *entry;
curattr->refcount++; Z_ADDREF_P(curattr);
} }
} else { } else {
curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->ptr)->node; curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->ptr)->node;
@ -273,7 +273,7 @@ zend_object_iterator *php_dom_get_iterator(zend_class_entry *ce, zval *object, i
} }
iterator = emalloc(sizeof(php_dom_iterator)); iterator = emalloc(sizeof(php_dom_iterator));
object->refcount++; Z_ADDREF_P(object);
iterator->intern.data = (void*)object; iterator->intern.data = (void*)object;
iterator->intern.funcs = &php_dom_iterator_funcs; iterator->intern.funcs = &php_dom_iterator_funcs;
@ -287,7 +287,7 @@ zend_object_iterator *php_dom_get_iterator(zend_class_entry *ce, zval *object, i
zend_hash_internal_pointer_reset(nodeht); zend_hash_internal_pointer_reset(nodeht);
if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) { if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
curattr = *entry; curattr = *entry;
curattr->refcount++; Z_ADDREF_P(curattr);
} }
} else { } else {
nodep = (xmlNode *)dom_object_get_node(objmap->baseobj); nodep = (xmlNode *)dom_object_get_node(objmap->baseobj);

4
ext/dom/node.c
View file

@ -240,7 +240,7 @@ int dom_node_node_value_write(dom_object *obj, zval *newval TSRMLS_DC)
case XML_CDATA_SECTION_NODE: case XML_CDATA_SECTION_NODE:
case XML_PI_NODE: case XML_PI_NODE:
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;
@ -700,7 +700,7 @@ int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC)
} }
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;

12
ext/dom/php_dom.c
View file

@ -336,8 +336,8 @@ zval *dom_read_property(zval *object, zval *member, int type TSRMLS_DC)
ret = hnd->read_func(obj, &retval TSRMLS_CC); ret = hnd->read_func(obj, &retval TSRMLS_CC);
if (ret == SUCCESS) { if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */ /* ensure we're creating a temporary variable */
retval->refcount = 0; Z_SET_REFCOUNT_P(retval, 0);
retval->is_ref = 0; Z_UNSET_ISREF_P(retval);
} else { } else {
retval = EG(uninitialized_zval_ptr); retval = EG(uninitialized_zval_ptr);
} }
@ -416,8 +416,8 @@ static int dom_property_exists(zval *object, zval *member, int check_empty TSRML
if (check_empty == 2) { if (check_empty == 2) {
retval = 1; retval = 1;
} else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) { } else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
tmp->refcount = 1; Z_SET_REFCOUNT_P(tmp, 1);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
if (check_empty == 1) { if (check_empty == 1) {
retval = zend_is_true(tmp); retval = zend_is_true(tmp);
} else if (check_empty == 0) { } else if (check_empty == 0) {
@ -1006,7 +1006,7 @@ void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xml
if (basenode) { if (basenode) {
MAKE_STD_ZVAL(baseobj); MAKE_STD_ZVAL(baseobj);
baseobj->type = IS_OBJECT; baseobj->type = IS_OBJECT;
baseobj->is_ref = 1; Z_SET_ISREF_P(baseobj);
baseobj->value.obj.handle = basenode->handle; baseobj->value.obj.handle = basenode->handle;
baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C); baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
zval_copy_ctor(baseobj); zval_copy_ctor(baseobj);
@ -1201,7 +1201,7 @@ PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *wra
if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) { if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
return_value->type = IS_OBJECT; return_value->type = IS_OBJECT;
return_value->is_ref = 1; Z_SET_ISREF_P(return_value);
return_value->value.obj.handle = intern->handle; return_value->value.obj.handle = intern->handle;
return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C); return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
zval_copy_ctor(return_value); zval_copy_ctor(return_value);

2
ext/dom/processinginstruction.c
View file

@ -151,7 +151,7 @@ int dom_processinginstruction_data_write(dom_object *obj, zval *newval TSRMLS_DC
} }
if (newval->type != IS_STRING) { if (newval->type != IS_STRING) {
if(newval->refcount > 1) { if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval; value_copy = *newval;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
newval = &value_copy; newval = &value_copy;

2
ext/iconv/iconv.c
View file

@ -2278,7 +2278,7 @@ PHP_FUNCTION(iconv_mime_decode_headers)
MAKE_STD_ZVAL(new_elem); MAKE_STD_ZVAL(new_elem);
array_init(new_elem); array_init(new_elem);
ZVAL_ADDREF(*elem); Z_ADDREF_PP(elem);
add_next_index_zval(new_elem, *elem); add_next_index_zval(new_elem, *elem);
zend_hash_update(Z_ARRVAL_P(return_value), header_name, header_name_len, (void *)&new_elem, sizeof(new_elem), NULL); zend_hash_update(Z_ARRVAL_P(return_value), header_name, header_name_len, (void *)&new_elem, sizeof(new_elem), NULL);

6
ext/json/JSON_parser.c
View file

@ -364,7 +364,7 @@ static void attach_zval(json_parser *json, int up, int cur, smart_str *key, int
{ {
add_property_zval_ex(root, (key->len ? key->c : "_empty_"), (key->len ? (key->len + 1) : sizeof("_empty_")), child TSRMLS_CC); add_property_zval_ex(root, (key->len ? key->c : "_empty_"), (key->len ? (key->len + 1) : sizeof("_empty_")), child TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5 #if PHP_MAJOR_VERSION >= 5
ZVAL_DELREF(child); Z_DELREF_P(child);
#endif #endif
} }
else else
@ -507,7 +507,7 @@ JSON_parser(zval *z, unsigned short p[], int length, int assoc TSRMLS_DC)
{ {
add_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC); add_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5 #if PHP_MAJOR_VERSION >= 5
ZVAL_DELREF(mval); Z_DELREF_P(mval);
#endif #endif
} }
else else
@ -638,7 +638,7 @@ JSON_parser(zval *z, unsigned short p[], int length, int assoc TSRMLS_DC)
{ {
add_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC); add_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5 #if PHP_MAJOR_VERSION >= 5
ZVAL_DELREF(mval); Z_DELREF_P(mval);
#endif #endif
} }
else else

2
ext/libxml/libxml.c
View file

@ -710,7 +710,7 @@ static PHP_FUNCTION(libxml_set_streams_context)
zval_ptr_dtor(&LIBXML(stream_context)); zval_ptr_dtor(&LIBXML(stream_context));
LIBXML(stream_context) = NULL; LIBXML(stream_context) = NULL;
} }
ZVAL_ADDREF(arg); Z_ADDREF_P(arg);
LIBXML(stream_context) = arg; LIBXML(stream_context) = arg;
} }
/* }}} */ /* }}} */

4
ext/mbstring/mbstring.c
View file

@ -3172,8 +3172,8 @@ detect_end:
string.len = Z_STRLEN_PP(hash_entry); string.len = Z_STRLEN_PP(hash_entry);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result); ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
if (ret != NULL) { if (ret != NULL) {
if ((*hash_entry)->refcount > 1) { if (Z_REFCOUNT_PP(hash_entry) > 1) {
ZVAL_DELREF(*hash_entry); Z_DELREF_PP(hash_entry);
MAKE_STD_ZVAL(*hash_entry); MAKE_STD_ZVAL(*hash_entry);
} else { } else {
zval_dtor(*hash_entry); zval_dtor(*hash_entry);

2
ext/mbstring/php_mbregex.c
View file

@ -1112,7 +1112,7 @@ PHP_FUNCTION(mb_ereg_search_init)
} }
MBSTRG(search_str) = *arg_str; MBSTRG(search_str) = *arg_str;
ZVAL_ADDREF(MBSTRG(search_str)); Z_ADDREF_P(MBSTRG(search_str));
SEPARATE_ZVAL_IF_NOT_REF(&MBSTRG(search_str)); SEPARATE_ZVAL_IF_NOT_REF(&MBSTRG(search_str));
MBSTRG(search_pos) = 0; MBSTRG(search_pos) = 0;

2
ext/mysql/php_mysql.c
View file

@ -2065,7 +2065,7 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type,
} }
if (result_type & MYSQL_ASSOC) { if (result_type & MYSQL_ASSOC) {
if (result_type & MYSQL_NUM) { if (result_type & MYSQL_NUM) {
ZVAL_ADDREF(data); Z_ADDREF_P(data);
} }
add_assoc_zval(return_value, mysql_field->name, data); add_assoc_zval(return_value, mysql_field->name, data);
} }

8
ext/mysqli/mysqli.c
View file

@ -352,7 +352,7 @@ zval *mysqli_read_property(zval *object, zval *member, int type TSRMLS_DC)
ret = hnd->read_func(obj, &retval TSRMLS_CC); ret = hnd->read_func(obj, &retval TSRMLS_CC);
if (ret == SUCCESS) { if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */ /* ensure we're creating a temporary variable */
retval->refcount = 0; Z_SET_REFCOUNT_P(retval, 0);
} else { } else {
retval = EG(uninitialized_zval_ptr); retval = EG(uninitialized_zval_ptr);
} }
@ -392,8 +392,8 @@ void mysqli_write_property(zval *object, zval *member, zval *value TSRMLS_DC)
} }
if (ret == SUCCESS) { if (ret == SUCCESS) {
hnd->write_func(obj, value TSRMLS_CC); hnd->write_func(obj, value TSRMLS_CC);
if (! PZVAL_IS_REF(value) && value->refcount == 0) { if (! PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) == 0) {
value->refcount++; Z_ADDREF_P(value);
zval_ptr_dtor(&value); zval_ptr_dtor(&value);
} }
} else { } else {
@ -1092,7 +1092,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags
} }
if (fetchtype & MYSQLI_ASSOC) { if (fetchtype & MYSQLI_ASSOC) {
if (fetchtype & MYSQLI_NUM) { if (fetchtype & MYSQLI_NUM) {
ZVAL_ADDREF(res); Z_ADDREF_P(res);
} }
add_assoc_zval(return_value, fields[i].name, res); add_assoc_zval(return_value, fields[i].name, res);
} }

4
ext/mysqli/mysqli_api.c
View file

@ -138,7 +138,7 @@ end_1:
stmt->param.vars = (zval **)safe_emalloc(num_vars, sizeof(zval), 0); stmt->param.vars = (zval **)safe_emalloc(num_vars, sizeof(zval), 0);
for (i = 0; i < num_vars; i++) { for (i = 0; i < num_vars; i++) {
if (bind[i].buffer_type != MYSQL_TYPE_LONG_BLOB) { if (bind[i].buffer_type != MYSQL_TYPE_LONG_BLOB) {
ZVAL_ADDREF(*args[i+start]); Z_ADDREF_PP(*args[i+start]);
stmt->param.vars[i] = *args[i+start]; stmt->param.vars[i] = *args[i+start];
} else { } else {
stmt->param.vars[i] = NULL; stmt->param.vars[i] = NULL;
@ -426,7 +426,7 @@ mysqli_stmt_bind_result_do_bind(MY_STMT *stmt, zval ***args, unsigned int argc,
stmt->result.vars = (zval **)safe_emalloc((var_cnt), sizeof(zval), 0); stmt->result.vars = (zval **)safe_emalloc((var_cnt), sizeof(zval), 0);
for (i = start; i < var_cnt+start; i++) { for (i = start; i < var_cnt+start; i++) {
ofs = i-start; ofs = i-start;
ZVAL_ADDREF(*args[i]); Z_ADDREF_PP(args[i]);
stmt->result.vars[ofs] = *args[i]; stmt->result.vars[ofs] = *args[i];
} }
} }

2
ext/oci8/oci8.c
View file

@ -1754,7 +1754,7 @@ void php_oci_fetch_row (INTERNAL_FUNCTION_PARAMETERS, int mode, int expected_arg
} }
if (fetch_mode & PHP_OCI_ASSOC) { if (fetch_mode & PHP_OCI_ASSOC) {
if (fetch_mode & PHP_OCI_NUM) { if (fetch_mode & PHP_OCI_NUM) {
ZVAL_ADDREF(element); Z_ADDREF_P(element);
} }
add_assoc_zval(return_value, column->name, element); add_assoc_zval(return_value, column->name, element);
} }

4
ext/pcre/php_pcre.c
View file

@ -723,7 +723,7 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
if (subpat_names[i]) { if (subpat_names[i]) {
zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i], zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i],
strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL); strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL);
ZVAL_ADDREF(match_sets[i]); Z_ADDREF_P(match_sets[i]);
} }
zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL); zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL);
} }
@ -1723,7 +1723,7 @@ PHPAPI void php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return
/* If the entry fits our requirements */ /* If the entry fits our requirements */
if ((count > 0 && !invert) || if ((count > 0 && !invert) ||
(count == PCRE_ERROR_NOMATCH && invert)) { (count == PCRE_ERROR_NOMATCH && invert)) {
(*entry)->refcount++; Z_ADDREF_PP(entry);
/* Add to return array */ /* Add to return array */
switch (zend_hash_get_current_key(Z_ARRVAL_P(input), &string_key, &num_key, 0)) switch (zend_hash_get_current_key(Z_ARRVAL_P(input), &string_key, &num_key, 0))

8
ext/pdo/pdo_dbh.c
View file

@ -429,8 +429,8 @@ static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry
Z_TYPE_P(object) = IS_OBJECT; Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, dbstmt_ce); object_init_ex(object, dbstmt_ce);
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 1; Z_SET_ISREF_P(object);
return object; return object;
} /* }}} */ } /* }}} */
@ -778,7 +778,7 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
PDO_HANDLE_DBH_ERR(); PDO_HANDLE_DBH_ERR();
return FAILURE; return FAILURE;
} }
(*item)->refcount++; Z_ADDREF_PP(item);
dbh->def_stmt_ctor_args = *item; dbh->def_stmt_ctor_args = *item;
} }
return SUCCESS; return SUCCESS;
@ -865,7 +865,7 @@ static PHP_METHOD(PDO, getAttribute)
array_init(return_value); array_init(return_value);
add_next_index_string(return_value, dbh->def_stmt_ce->name, 1); add_next_index_string(return_value, dbh->def_stmt_ce->name, 1);
if (dbh->def_stmt_ctor_args) { if (dbh->def_stmt_ctor_args) {
dbh->def_stmt_ctor_args->refcount++; Z_ADDREF_P(dbh->def_stmt_ctor_args);
add_next_index_zval(return_value, dbh->def_stmt_ctor_args); add_next_index_zval(return_value, dbh->def_stmt_ctor_args);
} }
return; return;

14
ext/pdo/pdo_stmt.c
View file

@ -321,7 +321,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
param->is_param = is_param; param->is_param = is_param;
if (param->driver_params) { if (param->driver_params) {
ZVAL_ADDREF(param->driver_params); Z_ADDREF_P(param->driver_params);
} }
if (!is_param && param->name && stmt->columns) { if (!is_param && param->name && stmt->columns) {
@ -1088,7 +1088,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
case PDO_FETCH_USE_DEFAULT: case PDO_FETCH_USE_DEFAULT:
case PDO_FETCH_BOTH: case PDO_FETCH_BOTH:
add_assoc_zval(return_value, stmt->columns[i].name, val); add_assoc_zval(return_value, stmt->columns[i].name, val);
ZVAL_ADDREF(val); Z_ADDREF_P(val);
add_next_index_zval(return_value, val); add_next_index_zval(return_value, val);
break; break;
@ -1621,7 +1621,7 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
return 0; return 0;
} }
ZVAL_ADDREF(param.parameter); Z_ADDREF_P(param.parameter);
if (!really_register_bound_param(&param, stmt, is_param TSRMLS_CC)) { if (!really_register_bound_param(&param, stmt, is_param TSRMLS_CC)) {
if (param.parameter) { if (param.parameter) {
zval_ptr_dtor(&(param.parameter)); zval_ptr_dtor(&(param.parameter));
@ -1657,7 +1657,7 @@ static PHP_METHOD(PDOStatement, bindValue)
RETURN_FALSE; RETURN_FALSE;
} }
ZVAL_ADDREF(param.parameter); Z_ADDREF_P(param.parameter);
if (!really_register_bound_param(&param, stmt, TRUE TSRMLS_CC)) { if (!really_register_bound_param(&param, stmt, TRUE TSRMLS_CC)) {
if (param.parameter) { if (param.parameter) {
zval_ptr_dtor(&(param.parameter)); zval_ptr_dtor(&(param.parameter));
@ -1877,7 +1877,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
switch (stmt->default_fetch_type) { switch (stmt->default_fetch_type) {
case PDO_FETCH_INTO: case PDO_FETCH_INTO:
if (stmt->fetch.into) { if (stmt->fetch.into) {
ZVAL_DELREF(stmt->fetch.into); Z_DELREF_P(stmt->fetch.into);
stmt->fetch.into = NULL; stmt->fetch.into = NULL;
} }
break; break;
@ -2548,8 +2548,8 @@ static zval *row_prop_or_dim_read(zval *object, zval *member, int type TSRMLS_DC
} }
} }
return_value->refcount = 0; Z_SET_REFCOUNT_P(return_value, 0);
return_value->is_ref = 0; Z_UNSET_ISREF_P(return_value);
return return_value; return return_value;
} }

16
ext/reflection/php_reflection.c
View file

@ -278,8 +278,8 @@ static zval * reflection_instantiate(zend_class_entry *pce, zval *object TSRMLS_
} }
Z_TYPE_P(object) = IS_OBJECT; Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce); object_init_ex(object, pce);
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 1; Z_SET_ISREF_P(object);
return object; return object;
} }
@ -2788,13 +2788,13 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue)
"Class %s does not have a property named %s", ce->name, name); "Class %s does not have a property named %s", ce->name, name);
return; return;
} }
refcount = (*variable_ptr)->refcount; refcount = Z_REFCOUNT_PP(variable_ptr);
is_ref = (*variable_ptr)->is_ref; is_ref = Z_ISREF_PP(variable_ptr);
zval_dtor(*variable_ptr); zval_dtor(*variable_ptr);
**variable_ptr = *value; **variable_ptr = *value;
zval_copy_ctor(*variable_ptr); zval_copy_ctor(*variable_ptr);
(*variable_ptr)->refcount = refcount; Z_SET_REFCOUNT_PP(variable_ptr, refcount);
(*variable_ptr)->is_ref = is_ref; Z_SET_ISREF_TO_PP(variable_ptr, is_ref);
} }
/* }}} */ /* }}} */
@ -4031,7 +4031,7 @@ ZEND_METHOD(reflection_property, setValue)
zval_dtor(*variable_ptr); zval_dtor(*variable_ptr);
(*variable_ptr)->type = value->type; (*variable_ptr)->type = value->type;
(*variable_ptr)->value = value->value; (*variable_ptr)->value = value->value;
if (value->refcount > 0) { if (Z_REFCOUNT_P(value) > 0) {
zval_copy_ctor(*variable_ptr); zval_copy_ctor(*variable_ptr);
} }
setter_done = 1; setter_done = 1;
@ -4040,7 +4040,7 @@ ZEND_METHOD(reflection_property, setValue)
if (!setter_done) { if (!setter_done) {
zval **foo; zval **foo;
value->refcount++; Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) { if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value); SEPARATE_ZVAL(&value);
} }

6
ext/session/session.c
View file

@ -339,7 +339,7 @@ PHPAPI void php_add_session_var(char *name, size_t namelen TSRMLS_DC)
zval *empty_var; zval *empty_var;
ALLOC_INIT_ZVAL(empty_var); /* this sets refcount to 1 */ ALLOC_INIT_ZVAL(empty_var); /* this sets refcount to 1 */
empty_var->refcount = 0; /* our module does not maintain a ref */ Z_SET_REFCOUNT_P(empty_var, 0); /* our module does not maintain a ref */
/* The next call will increase refcount by NR_OF_SYM_TABLES==2 */ /* The next call will increase refcount by NR_OF_SYM_TABLES==2 */
zend_set_hash_symbol(empty_var, name, namelen, 1, 2, Z_ARRVAL_P(PS(http_session_vars)), &EG(symbol_table)); zend_set_hash_symbol(empty_var, name, namelen, 1, 2, Z_ARRVAL_P(PS(http_session_vars)), &EG(symbol_table));
} else if (sym_global == NULL) { } else if (sym_global == NULL) {
@ -869,7 +869,7 @@ static int migrate_global(HashTable *ht, HashPosition *pos TSRMLS_DC)
(void **) &val) == SUCCESS (void **) &val) == SUCCESS
&& val && Z_TYPE_PP(val) != IS_NULL) { && val && Z_TYPE_PP(val) != IS_NULL) {
ZEND_SET_SYMBOL_WITH_LENGTH(ht, str, str_len, *val, ZEND_SET_SYMBOL_WITH_LENGTH(ht, str, str_len, *val,
(*val)->refcount + 1 , 1); Z_REFCOUNT_PP(val) + 1 , 1);
ret = 1; ret = 1;
} }
break; break;
@ -1512,7 +1512,7 @@ PHP_FUNCTION(session_set_save_handler)
mdata = emalloc(sizeof(*mdata)); mdata = emalloc(sizeof(*mdata));
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
ZVAL_ADDREF(*args[i]); Z_ADDREF_PP(args[i]);
mdata->names[i] = *args[i]; mdata->names[i] = *args[i];
} }

18
ext/simplexml/simplexml.c
View file

@ -365,8 +365,8 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
} }
} }
return_value->refcount = 0; Z_SET_REFCOUNT_P(return_value, 0);
return_value->is_ref = 0; Z_UNSET_ISREF_P(return_value);
if (member == &tmp_zv) { if (member == &tmp_zv) {
zval_dtor(&tmp_zv); zval_dtor(&tmp_zv);
@ -414,7 +414,7 @@ static void change_node_zval(xmlNodePtr node, zval *value TSRMLS_DC)
case IS_BOOL: case IS_BOOL:
case IS_DOUBLE: case IS_DOUBLE:
case IS_NULL: case IS_NULL:
if (value->refcount > 1) { if (Z_REFCOUNT_P(value) > 1) {
value_copy = *value; value_copy = *value;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
value = &value_copy; value = &value_copy;
@ -534,7 +534,7 @@ static void sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_boo
case IS_BOOL: case IS_BOOL:
case IS_DOUBLE: case IS_DOUBLE:
case IS_NULL: case IS_NULL:
if (value->refcount > 1) { if (Z_REFCOUNT_P(value) > 1) {
value_copy = *value; value_copy = *value;
zval_copy_ctor(&value_copy); zval_copy_ctor(&value_copy);
value = &value_copy; value = &value_copy;
@ -712,7 +712,7 @@ static zval** sxe_property_get_adr(zval *object, zval *member TSRMLS_DC) /* {{{
sxe = php_sxe_fetch_object(return_value TSRMLS_CC); sxe = php_sxe_fetch_object(return_value TSRMLS_CC);
sxe->tmp = return_value; sxe->tmp = return_value;
return_value->is_ref = 1; Z_SET_ISREF_P(return_value);
return &sxe->tmp; return &sxe->tmp;
} }
@ -1673,8 +1673,8 @@ static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
} else { } else {
ZVAL_NULL(object); ZVAL_NULL(object);
} }
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 0; Z_UNSET_ISREF_P(object);
switch (type) { switch (type) {
case IS_STRING: case IS_STRING:
@ -1782,7 +1782,7 @@ static zval *sxe_get_value(zval *z TSRMLS_DC)
/* FIXME: Should not be fatal */ /* FIXME: Should not be fatal */
} }
retval->refcount = 0; Z_SET_REFCOUNT_P(retval, 0);
return retval; return retval;
} }
@ -2195,7 +2195,7 @@ zend_object_iterator *php_sxe_get_iterator(zend_class_entry *ce, zval *object, i
} }
iterator = emalloc(sizeof(php_sxe_iterator)); iterator = emalloc(sizeof(php_sxe_iterator));
object->refcount++; Z_ADDREF_P(object);
iterator->intern.data = (void*)object; iterator->intern.data = (void*)object;
iterator->intern.funcs = &php_sxe_iterator_funcs; iterator->intern.funcs = &php_sxe_iterator_funcs;
iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC); iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC);

10
ext/soap/php_encoding.c
View file

@ -346,8 +346,8 @@ static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC)
if (*data != *data_ptr) { if (*data != *data_ptr) {
zval_ptr_dtor(data); zval_ptr_dtor(data);
*data = *data_ptr; *data = *data_ptr;
(*data)->is_ref = 1; Z_SET_ISREF_PP(data);
(*data)->refcount++; Z_ADDREF_PP(data);
return 1; return 1;
} }
} else { } else {
@ -1195,7 +1195,7 @@ static void set_zval_property(zval* object, char* name, zval* val TSRMLS_DC)
old_scope = EG(scope); old_scope = EG(scope);
EG(scope) = Z_OBJCE_P(object); EG(scope) = Z_OBJCE_P(object);
#ifdef ZEND_ENGINE_2 #ifdef ZEND_ENGINE_2
val->refcount--; Z_DELREF_P(val);
#endif #endif
add_property_zval(object, name, val); add_property_zval(object, name, val);
EG(scope) = old_scope; EG(scope) = old_scope;
@ -1621,7 +1621,7 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
MAKE_STD_ZVAL(arr); MAKE_STD_ZVAL(arr);
array_init(arr); array_init(arr);
prop->refcount++; Z_ADDREF_P(prop);
add_next_index_zval(arr, prop); add_next_index_zval(arr, prop);
set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC); set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
prop = arr; prop = arr;
@ -2843,7 +2843,7 @@ static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data)
object_init_ex(soapvar, soap_var_class_entry); object_init_ex(soapvar, soap_var_class_entry);
add_property_long(soapvar, "enc_type", enc->details.type); add_property_long(soapvar, "enc_type", enc->details.type);
#ifdef ZEND_ENGINE_2 #ifdef ZEND_ENGINE_2
ret->refcount--; Z_DELREF_P(ret);
#endif #endif
add_property_zval(soapvar, "enc_value", ret); add_property_zval(soapvar, "enc_value", ret);
parse_namespace(type_name, &cptype, &ns); parse_namespace(type_name, &cptype, &ns);

2
ext/soap/php_http.c
View file

@ -994,7 +994,7 @@ try_again:
if (digest != NULL) { if (digest != NULL) {
php_url *new_url = emalloc(sizeof(php_url)); php_url *new_url = emalloc(sizeof(php_url));
digest->refcount--; Z_DELREF_P(digest);
add_property_zval_ex(this_ptr, "_digest", sizeof("_digest"), digest TSRMLS_CC); add_property_zval_ex(this_ptr, "_digest", sizeof("_digest"), digest TSRMLS_CC);
*new_url = *phpurl; *new_url = *phpurl;

4
ext/soap/php_packet_soap.c
View file

@ -241,7 +241,7 @@ int parse_packet_soap(zval *this_ptr, char *buffer, int buffer_size, sdlFunction
} }
#ifdef ZEND_ENGINE_2 #ifdef ZEND_ENGINE_2
if (details) { if (details) {
details->refcount--; Z_DELREF_P(details);
} }
#endif #endif
xmlFreeDoc(response); xmlFreeDoc(response);
@ -387,7 +387,7 @@ int parse_packet_soap(zval *this_ptr, char *buffer, int buffer_size, sdlFunction
zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value)); zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value));
zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void**)&tmp); zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void**)&tmp);
tmp = *(zval**)tmp; tmp = *(zval**)tmp;
tmp->refcount++; Z_ADDREF_P(tmp);
zval_dtor(return_value); zval_dtor(return_value);
*return_value = *tmp; *return_value = *tmp;
FREE_ZVAL(tmp); FREE_ZVAL(tmp);

12
ext/soap/soap.c
View file

@ -2379,7 +2379,7 @@ PHP_METHOD(SoapClient, SoapClient)
INIT_PZVAL(class_map); INIT_PZVAL(class_map);
zval_copy_ctor(class_map); zval_copy_ctor(class_map);
#ifdef ZEND_ENGINE_2 #ifdef ZEND_ENGINE_2
class_map->refcount--; Z_DELREF_P(class_map);
#endif #endif
add_property_zval(this_ptr, "_classmap", class_map); add_property_zval(this_ptr, "_classmap", class_map);
} }
@ -2795,7 +2795,7 @@ PHP_METHOD(SoapClient, __call)
soap_headers = emalloc(sizeof(HashTable)); soap_headers = emalloc(sizeof(HashTable));
zend_hash_init(soap_headers, 0, NULL, ZVAL_PTR_DTOR, 0); zend_hash_init(soap_headers, 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_next_index_insert(soap_headers, &headers, sizeof(zval*), NULL); zend_hash_next_index_insert(soap_headers, &headers, sizeof(zval*), NULL);
ZVAL_ADDREF(headers); Z_ADDREF_P(headers);
free_soap_headers = 1; free_soap_headers = 1;
} else{ } else{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header"); php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header");
@ -2814,7 +2814,7 @@ PHP_METHOD(SoapClient, __call)
} }
zend_hash_internal_pointer_reset(default_headers); zend_hash_internal_pointer_reset(default_headers);
while (zend_hash_get_current_data(default_headers, (void**)&tmp) == SUCCESS) { while (zend_hash_get_current_data(default_headers, (void**)&tmp) == SUCCESS) {
ZVAL_ADDREF(*tmp); Z_ADDREF_PP(tmp);
zend_hash_next_index_insert(soap_headers, tmp, sizeof(zval *), NULL); zend_hash_next_index_insert(soap_headers, tmp, sizeof(zval *), NULL);
zend_hash_move_forward(default_headers); zend_hash_move_forward(default_headers);
} }
@ -3060,9 +3060,9 @@ PHP_METHOD(SoapClient, __setSoapHeaders)
zval *default_headers; zval *default_headers;
ALLOC_INIT_ZVAL(default_headers); ALLOC_INIT_ZVAL(default_headers);
array_init(default_headers); array_init(default_headers);
headers->refcount++; Z_ADDREF_P(headers);
add_next_index_zval(default_headers, headers); add_next_index_zval(default_headers, headers);
default_headers->refcount--; Z_DELREF_P(default_headers);
add_property_zval(this_ptr, "__default_headers", default_headers); add_property_zval(this_ptr, "__default_headers", default_headers);
} else{ } else{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header"); php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header");
@ -3152,7 +3152,7 @@ zval* add_soap_fault(zval *obj, char *fault_code, char *fault_string, char *faul
ALLOC_INIT_ZVAL(fault); ALLOC_INIT_ZVAL(fault);
set_soap_fault(fault, NULL, fault_code, fault_string, fault_actor, fault_detail, NULL TSRMLS_CC); set_soap_fault(fault, NULL, fault_code, fault_string, fault_actor, fault_detail, NULL TSRMLS_CC);
#ifdef ZEND_ENGINE_2 #ifdef ZEND_ENGINE_2
fault->refcount--; Z_DELREF_P(fault);
#endif #endif
add_property_zval(obj, "__soap_fault", fault); add_property_zval(obj, "__soap_fault", fault);
return fault; return fault;

2
ext/spl/php_spl.c
View file

@ -468,7 +468,7 @@ PHP_FUNCTION(spl_autoload_register)
func_name_len += sizeof(zend_object_handle); func_name_len += sizeof(zend_object_handle);
lc_name[func_name_len] = '\0'; lc_name[func_name_len] = '\0';
alfi.obj = *obj_ptr; alfi.obj = *obj_ptr;
alfi.obj->refcount++; Z_ADDREF_P(alfi.obj);
} else { } else {
alfi.obj = NULL; alfi.obj = NULL;
} }

32
ext/spl/spl_array.c
View file

@ -152,11 +152,11 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s
zend_hash_copy(HASH_OF(intern->array), HASH_OF(other->array), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*)); zend_hash_copy(HASH_OF(intern->array), HASH_OF(other->array), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
} }
if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) { if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) {
ZVAL_ADDREF(other->array); Z_ADDREF_P(other->array);
} }
} else { } else {
intern->array = orig; intern->array = orig;
ZVAL_ADDREF(intern->array); Z_ADDREF_P(intern->array);
intern->ar_flags |= SPL_ARRAY_IS_REF | SPL_ARRAY_USE_OTHER; intern->ar_flags |= SPL_ARRAY_IS_REF | SPL_ARRAY_USE_OTHER;
} }
} else { } else {
@ -320,22 +320,22 @@ static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval
/* When in a write context, /* When in a write context,
* ZE has to be fooled into thinking this is in a reference set * ZE has to be fooled into thinking this is in a reference set
* by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) */ * by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) */
if ((type == BP_VAR_W || type == BP_VAR_RW) && !(*ret)->is_ref) { if ((type == BP_VAR_W || type == BP_VAR_RW) && !Z_ISREF_PP(ret)) {
if ((*ret)->refcount > 1) { if (Z_REFCOUNT_PP(ret) > 1) {
zval *newval; zval *newval;
/* Separate */ /* Separate */
MAKE_STD_ZVAL(newval); MAKE_STD_ZVAL(newval);
*newval = **ret; *newval = **ret;
zval_copy_ctor(newval); zval_copy_ctor(newval);
newval->refcount = 1; Z_SET_REFCOUNT_P(newval, 1);
/* Replace */ /* Replace */
(*ret)->refcount--; Z_DELREF_PP(ret);
*ret = newval; *ret = newval;
} }
(*ret)->is_ref = 1; Z_SET_ISREF_PP(ret);
} }
return *ret; return *ret;
@ -363,7 +363,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
} }
if (!offset) { if (!offset) {
value->refcount++; Z_ADDREF_P(value);
zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL); zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL);
return; return;
} }
@ -373,7 +373,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
zend_throw_exception(spl_ce_InvalidArgumentException, "An offset must not begin with \\0 or be empty", 0 TSRMLS_CC); zend_throw_exception(spl_ce_InvalidArgumentException, "An offset must not begin with \\0 or be empty", 0 TSRMLS_CC);
return; return;
} }
value->refcount++; Z_ADDREF_P(value);
zend_symtable_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL); zend_symtable_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL);
return; return;
case IS_DOUBLE: case IS_DOUBLE:
@ -385,11 +385,11 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
} else { } else {
index = Z_LVAL_P(offset); index = Z_LVAL_P(offset);
} }
value->refcount++; Z_ADDREF_P(value);
zend_hash_index_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), index, (void**)&value, sizeof(void*), NULL); zend_hash_index_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), index, (void**)&value, sizeof(void*), NULL);
return; return;
case IS_NULL: case IS_NULL:
value->refcount++; Z_ADDREF_P(value);
zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL); zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL);
return; return;
default: default:
@ -873,7 +873,7 @@ zend_object_iterator *spl_array_get_iterator(zend_class_entry *ce, zval *object,
iterator = emalloc(sizeof(spl_array_it)); iterator = emalloc(sizeof(spl_array_it));
object->refcount++; Z_ADDREF_P(object);
iterator->intern.it.data = (void*)object; iterator->intern.it.data = (void*)object;
iterator->intern.it.funcs = &spl_array_it_funcs; iterator->intern.it.funcs = &spl_array_it_funcs;
iterator->intern.ce = ce; iterator->intern.ce = ce;
@ -949,7 +949,7 @@ SPL_METHOD(Array, __construct)
intern->ar_flags &= ~SPL_ARRAY_IS_SELF; intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
} }
intern->ar_flags |= ar_flags; intern->ar_flags |= ar_flags;
ZVAL_ADDREF(intern->array); Z_ADDREF_P(intern->array);
if (Z_TYPE_PP(array) == IS_OBJECT) { if (Z_TYPE_PP(array) == IS_OBJECT) {
zend_object_get_properties_t handler = Z_OBJ_HANDLER_PP(array, get_properties); zend_object_get_properties_t handler = Z_OBJ_HANDLER_PP(array, get_properties);
if ((handler != std_object_handlers.get_properties && handler != spl_array_get_properties) if ((handler != std_object_handlers.get_properties && handler != spl_array_get_properties)
@ -1063,7 +1063,7 @@ SPL_METHOD(Array, exchangeArray)
} else { } else {
intern->ar_flags &= ~SPL_ARRAY_IS_SELF; intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
} }
ZVAL_ADDREF(intern->array); Z_ADDREF_P(intern->array);
spl_array_rewind(intern TSRMLS_CC); spl_array_rewind(intern TSRMLS_CC);
} }
@ -1085,8 +1085,8 @@ SPL_METHOD(Array, getIterator)
return_value->type = IS_OBJECT; return_value->type = IS_OBJECT;
return_value->value.obj = spl_array_object_new_ex(intern->ce_get_iterator, &iterator, object, 0 TSRMLS_CC); return_value->value.obj = spl_array_object_new_ex(intern->ce_get_iterator, &iterator, object, 0 TSRMLS_CC);
return_value->refcount = 1; Z_SET_REFCOUNT_P(return_value, 1);
return_value->is_ref = 1; Z_SET_ISREF_P(return_value);
} }
/* }}} */ /* }}} */

6
ext/spl/spl_directory.c
View file

@ -231,7 +231,7 @@ static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_inclu
/* avoid reference counting in debug mode, thus do it manually */ /* avoid reference counting in debug mode, thus do it manually */
ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream)); ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream));
intern->u.file.zresource.refcount = 1; Z_SET_REFCOUNT(intern->u.file.zresource, 1);
intern->u.file.delimiter = ','; intern->u.file.delimiter = ',';
intern->u.file.enclosure = '"'; intern->u.file.enclosure = '"';
@ -1140,7 +1140,7 @@ zend_object_iterator *spl_filesystem_dir_get_iterator(zend_class_entry *ce, zval
iterator = emalloc(sizeof(spl_filesystem_dir_it)); iterator = emalloc(sizeof(spl_filesystem_dir_it));
dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC); dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
object->refcount += 2;; Z_SET_REFCOUNT_P(object, Z_REFCOUNT_P(object) + 2);
iterator->intern.data = (void*)object; iterator->intern.data = (void*)object;
iterator->intern.funcs = &spl_filesystem_dir_it_funcs; iterator->intern.funcs = &spl_filesystem_dir_it_funcs;
iterator->current = object; iterator->current = object;
@ -1351,7 +1351,7 @@ zend_object_iterator *spl_filesystem_tree_get_iterator(zend_class_entry *ce, zva
iterator = emalloc(sizeof(spl_filesystem_dir_it)); iterator = emalloc(sizeof(spl_filesystem_dir_it));
dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC); dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
object->refcount++; Z_ADDREF_P(object);
iterator->intern.data = (void*)object; iterator->intern.data = (void*)object;
iterator->intern.funcs = &spl_filesystem_tree_it_funcs; iterator->intern.funcs = &spl_filesystem_tree_it_funcs;
iterator->current = NULL; iterator->current = NULL;

4
ext/spl/spl_engine.c
View file

@ -38,8 +38,8 @@ PHPAPI void spl_instantiate(zend_class_entry *pce, zval **object, int alloc TSRM
ALLOC_ZVAL(*object); ALLOC_ZVAL(*object);
} }
object_init_ex(*object, pce); object_init_ex(*object, pce);
(*object)->refcount = 1; Z_SET_REFCOUNT_PP(object, 1);
(*object)->is_ref = 1; /* check if this can be hold always */ Z_SET_ISREF_PP(object); /* check if this can be hold always */
} }
/* }}} */ /* }}} */

18
ext/spl/spl_iterators.c
View file

@ -392,7 +392,7 @@ static zend_object_iterator *spl_recursive_it_get_iterator(zend_class_entry *ce,
iterator = emalloc(sizeof(spl_recursive_it_iterator)); iterator = emalloc(sizeof(spl_recursive_it_iterator));
object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC); object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC);
zobject->refcount++; Z_ADDREF_P(zobject);
iterator->intern.data = (void*)object; iterator->intern.data = (void*)object;
iterator->intern.funcs = ce->iterator_funcs.funcs; iterator->intern.funcs = ce->iterator_funcs.funcs;
iterator->zobject = zobject; iterator->zobject = zobject;
@ -479,7 +479,7 @@ SPL_METHOD(RecursiveIteratorIterator, __construct)
ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */ ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */
intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC); intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC);
if (inc_refcount) { if (inc_refcount) {
iterator->refcount++; Z_ADDREF_P(iterator);
} }
intern->iterators[0].zobject = iterator; intern->iterators[0].zobject = iterator;
intern->iterators[0].ce = ce_iterator; intern->iterators[0].ce = ce_iterator;
@ -1034,7 +1034,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
php_set_error_handling(EH_THROW, zend_exception_get_default(TSRMLS_C) TSRMLS_CC); php_set_error_handling(EH_THROW, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
if (inc_refcount) { if (inc_refcount) {
zobject->refcount++; Z_ADDREF_P(zobject);
} }
intern->inner.zobject = zobject; intern->inner.zobject = zobject;
intern->inner.ce = dit_type == DIT_IteratorIterator ? ce : Z_OBJCE_P(zobject); intern->inner.ce = dit_type == DIT_IteratorIterator ? ce : Z_OBJCE_P(zobject);
@ -1125,7 +1125,7 @@ static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more T
if (!check_more || spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) { if (!check_more || spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC); intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
intern->current.data = *data; intern->current.data = *data;
intern->current.data->refcount++; Z_ADDREF_P(intern->current.data);
if (intern->inner.iterator->funcs->get_current_key) { if (intern->inner.iterator->funcs->get_current_key) {
intern->current.key_type = intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.str_key, &intern->current.str_key_len, &intern->current.int_key TSRMLS_CC); intern->current.key_type = intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.str_key, &intern->current.str_key_len, &intern->current.int_key TSRMLS_CC);
} else { } else {
@ -2058,7 +2058,7 @@ SPL_METHOD(CachingIterator, offsetSet)
return; return;
} }
value->refcount++; Z_ADDREF_P(value);
zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL); zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL);
} }
/* }}} */ /* }}} */
@ -2502,7 +2502,7 @@ int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
zval **it; zval **it;
intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC); intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC);
(*it)->refcount++; Z_ADDREF_PP(it);
intern->inner.zobject = *it; intern->inner.zobject = *it;
intern->inner.ce = Z_OBJCE_PP(it); intern->inner.ce = Z_OBJCE_PP(it);
intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC); intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC);
@ -2700,7 +2700,7 @@ static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser T
if (EG(exception)) { if (EG(exception)) {
return ZEND_HASH_APPLY_STOP; return ZEND_HASH_APPLY_STOP;
} }
(*data)->refcount++; Z_ADDREF_PP(data);
switch(key_type) { switch(key_type) {
case HASH_KEY_IS_STRING: case HASH_KEY_IS_STRING:
add_assoc_zval_ex(return_value, str_key, str_key_len, *data); add_assoc_zval_ex(return_value, str_key, str_key_len, *data);
@ -2711,7 +2711,7 @@ static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser T
break; break;
} }
} else { } else {
(*data)->refcount++; Z_ADDREF_PP(data);
add_next_index_zval(return_value, *data); add_next_index_zval(return_value, *data);
} }
return ZEND_HASH_APPLY_KEEP; return ZEND_HASH_APPLY_KEEP;
@ -2726,7 +2726,7 @@ static int spl_iterator_to_values_apply(zend_object_iterator *iter, void *puser
if (EG(exception)) { if (EG(exception)) {
return ZEND_HASH_APPLY_STOP; return ZEND_HASH_APPLY_STOP;
} }
(*data)->refcount++; Z_ADDREF_PP(data);
add_next_index_zval(return_value, *data); add_next_index_zval(return_value, *data);
return ZEND_HASH_APPLY_KEEP; return ZEND_HASH_APPLY_KEEP;
} }

2
ext/spl/spl_observer.c
View file

@ -138,7 +138,7 @@ void spl_object_storage_attach(spl_SplObjectStorage *intern, zval *obj TSRMLS_DC
} }
#endif #endif
obj->refcount++; Z_ADDREF_P(obj);
} /* }}} */ } /* }}} */
/* {{{ proto void SplObjectStorage::attach($obj) /* {{{ proto void SplObjectStorage::attach($obj)

10
ext/sqlite/sqlite.c
View file

@ -628,7 +628,7 @@ static void php_sqlite_agg_step_function_callback(sqlite_func *func, int argc, c
if (*context_p == NULL) { if (*context_p == NULL) {
MAKE_STD_ZVAL(*context_p); MAKE_STD_ZVAL(*context_p);
(*context_p)->is_ref = 1; Z_SET_ISREF_PP(context_p);
Z_TYPE_PP(context_p) = IS_NULL; Z_TYPE_PP(context_p) = IS_NULL;
} }
@ -899,8 +899,8 @@ static zval * sqlite_instanciate(zend_class_entry *pce, zval *object TSRMLS_DC)
} }
Z_TYPE_P(object) = IS_OBJECT; Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce); object_init_ex(object, pce);
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 1; Z_SET_ISREF_P(object);
return object; return object;
} }
@ -1016,7 +1016,7 @@ zend_object_iterator *sqlite_get_iterator(zend_class_entry *ce, zval *object, in
if (by_ref) { if (by_ref) {
zend_error(E_RECOVERABLE_ERROR, "An iterator cannot be used with foreach by reference"); zend_error(E_RECOVERABLE_ERROR, "An iterator cannot be used with foreach by reference");
} }
object->refcount++; Z_ADDREF_P(object);
iterator->it.data = (void*)object; iterator->it.data = (void*)object;
iterator->it.funcs = ce->iterator_funcs.funcs; iterator->it.funcs = ce->iterator_funcs.funcs;
iterator->res = obj->u.res; iterator->res = obj->u.res;
@ -1858,7 +1858,7 @@ static void php_sqlite_fetch_array(struct php_sqlite_result *res, int mode, zend
if (mode & PHPSQLITE_NUM) { if (mode & PHPSQLITE_NUM) {
if (mode & PHPSQLITE_ASSOC) { if (mode & PHPSQLITE_ASSOC) {
add_index_zval(return_value, j, decoded); add_index_zval(return_value, j, decoded);
ZVAL_ADDREF(decoded); Z_ADDREF_P(decoded);
add_assoc_zval(return_value, (char*)colnames[j], decoded); add_assoc_zval(return_value, (char*)colnames[j], decoded);
} else { } else {
add_next_index_zval(return_value, decoded); add_next_index_zval(return_value, decoded);

36
ext/standard/array.c
View file

@ -1465,10 +1465,10 @@ PHP_FUNCTION(extract)
*orig_var = *entry; *orig_var = *entry;
} else { } else {
if (var_array->refcount > 1 || *entry == EG(uninitialized_zval_ptr)) { if (Z_REFCOUNT_P(var_array) > 1 || *entry == EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(entry); SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
} else { } else {
(*entry)->is_ref = 1; Z_SET_ISREF_PP(entry);
} }
zval_add_ref(entry); zval_add_ref(entry);
zend_hash_update(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) entry, sizeof(zval *), NULL); zend_hash_update(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) entry, sizeof(zval *), NULL);
@ -1889,7 +1889,7 @@ HashTable* php_splice(HashTable *in_hash, int offset, int length, zval ***list,
for (pos=0, p=in_hash->pListHead; pos<offset && p ; pos++, p=p->pListNext) { for (pos=0, p=in_hash->pListHead; pos<offset && p ; pos++, p=p->pListNext) {
/* Get entry and increase reference count */ /* Get entry and increase reference count */
entry = *((zval **)p->pData); entry = *((zval **)p->pData);
entry->refcount++; Z_ADDREF_P(entry);
/* Update output hash depending on key type */ /* Update output hash depending on key type */
if (p->nKeyLength) if (p->nKeyLength)
@ -1902,7 +1902,7 @@ HashTable* php_splice(HashTable *in_hash, int offset, int length, zval ***list,
if (removed != NULL) { if (removed != NULL) {
for ( ; pos<offset+length && p; pos++, p=p->pListNext) { for ( ; pos<offset+length && p; pos++, p=p->pListNext) {
entry = *((zval **)p->pData); entry = *((zval **)p->pData);
entry->refcount++; Z_ADDREF_P(entry);
if (p->nKeyLength) if (p->nKeyLength)
zend_hash_quick_update(*removed, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL); zend_hash_quick_update(*removed, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL);
else else
@ -1916,7 +1916,7 @@ HashTable* php_splice(HashTable *in_hash, int offset, int length, zval ***list,
/* ..for each one, create a new zval, copy entry into it and copy it into the output hash */ /* ..for each one, create a new zval, copy entry into it and copy it into the output hash */
for (i=0; i<list_count; i++) { for (i=0; i<list_count; i++) {
entry = *list[i]; entry = *list[i];
entry->refcount++; Z_ADDREF_P(entry);
zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL); zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
} }
} }
@ -1924,7 +1924,7 @@ HashTable* php_splice(HashTable *in_hash, int offset, int length, zval ***list,
/* Copy the remaining input hash entries to the output hash */ /* Copy the remaining input hash entries to the output hash */
for ( ; p ; p=p->pListNext) { for ( ; p ; p=p->pListNext) {
entry = *((zval **)p->pData); entry = *((zval **)p->pData);
entry->refcount++; Z_ADDREF_P(entry);
if (p->nKeyLength) if (p->nKeyLength)
zend_hash_quick_update(out_hash, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL); zend_hash_quick_update(out_hash, p->arKey, p->nKeyLength, p->h, &entry, sizeof(zval *), NULL);
else else
@ -1970,7 +1970,7 @@ PHP_FUNCTION(array_push)
/* For each subsequent argument, make it a reference, increase refcount, and add it to the end of the array */ /* For each subsequent argument, make it a reference, increase refcount, and add it to the end of the array */
for (i=1; i<argc; i++) { for (i=1; i<argc; i++) {
new_var = *args[i]; new_var = *args[i];
new_var->refcount++; Z_ADDREF_P(new_var);
if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var, sizeof(zval *), NULL) == FAILURE) { if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var, sizeof(zval *), NULL) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied"); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied");
@ -2277,7 +2277,7 @@ PHP_FUNCTION(array_slice)
/* Copy elements from input array to the one that's returned */ /* Copy elements from input array to the one that's returned */
while (pos < offset_val+length_val && zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &hpos) == SUCCESS) { while (pos < offset_val+length_val && zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &hpos) == SUCCESS) {
(*entry)->refcount++; Z_ADDREF_PP(entry);
switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(input), &string_key, &string_key_len, &num_key, 0, &hpos)) { switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(input), &string_key, &string_key_len, &num_key, 0, &hpos)) {
case HASH_KEY_IS_STRING: case HASH_KEY_IS_STRING:
@ -2314,7 +2314,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS
case HASH_KEY_IS_STRING: case HASH_KEY_IS_STRING:
if (recursive && if (recursive &&
zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == SUCCESS) { zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == SUCCESS) {
if (*src_entry == *dest_entry && ((*dest_entry)->refcount % 2)) { if (*src_entry == *dest_entry && (Z_REFCOUNT_PP(dest_entry) % 2)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
return 0; return 0;
} }
@ -2327,7 +2327,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS
Z_ARRVAL_PP(src_entry), recursive TSRMLS_CC)) Z_ARRVAL_PP(src_entry), recursive TSRMLS_CC))
return 0; return 0;
} else { } else {
(*src_entry)->refcount++; Z_ADDREF_PP(src_entry);
zend_hash_update(dest, string_key, string_key_len, zend_hash_update(dest, string_key, string_key_len,
src_entry, sizeof(zval *), NULL); src_entry, sizeof(zval *), NULL);
@ -2335,7 +2335,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS
break; break;
case HASH_KEY_IS_LONG: case HASH_KEY_IS_LONG:
(*src_entry)->refcount++; Z_ADDREF_PP(src_entry);
zend_hash_next_index_insert(dest, src_entry, sizeof(zval *), NULL); zend_hash_next_index_insert(dest, src_entry, sizeof(zval *), NULL);
break; break;
} }
@ -2504,7 +2504,7 @@ PHP_FUNCTION(array_values)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(input), &pos); zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(input), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &pos) == SUCCESS) { while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &pos) == SUCCESS) {
(*entry)->refcount++; Z_ADDREF_PP(entry);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry,
sizeof(zval *), NULL); sizeof(zval *), NULL);
@ -2602,7 +2602,7 @@ PHP_FUNCTION(array_reverse)
zend_hash_internal_pointer_end_ex(Z_ARRVAL_PP(input), &pos); zend_hash_internal_pointer_end_ex(Z_ARRVAL_PP(input), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &pos) == SUCCESS) { while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(input), (void **)&entry, &pos) == SUCCESS) {
(*entry)->refcount++; Z_ADDREF_PP(entry);
switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(input), &string_key, &string_key_len, &num_key, 0, &pos)) { switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(input), &string_key, &string_key_len, &num_key, 0, &pos)) {
case HASH_KEY_IS_STRING: case HASH_KEY_IS_STRING:
@ -2779,7 +2779,7 @@ PHP_FUNCTION(array_change_key_case)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(array), &pos); zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(array), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(array), (void **)&entry, &pos) == SUCCESS) { while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(array), (void **)&entry, &pos) == SUCCESS) {
(*entry)->refcount++; Z_ADDREF_PP(entry);
switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(array), &string_key, &str_key_len, &num_key, 0, &pos)) { switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(array), &string_key, &str_key_len, &num_key, 0, &pos)) {
case HASH_KEY_IS_LONG: case HASH_KEY_IS_LONG:
@ -2991,7 +2991,7 @@ static void php_array_intersect_key(INTERNAL_FUNCTION_PARAMETERS, int data_compa
} }
} }
if (ok) { if (ok) {
(*((zval**)p->pData))->refcount++; Z_ADDREF_PP((zval**)p->pData);
zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL); zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
} }
} else { } else {
@ -3005,7 +3005,7 @@ static void php_array_intersect_key(INTERNAL_FUNCTION_PARAMETERS, int data_compa
} }
} }
if (ok) { if (ok) {
(*((zval**)p->pData))->refcount++; Z_ADDREF_PP((zval**)p->pData);
zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL); zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
} }
} }
@ -3452,7 +3452,7 @@ static void php_array_diff_key(INTERNAL_FUNCTION_PARAMETERS, int data_compare_ty
} }
} }
if (ok) { if (ok) {
(*((zval**)p->pData))->refcount++; Z_ADDREF_PP((zval**)p->pData);
zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL); zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
} }
} else { } else {
@ -3466,7 +3466,7 @@ static void php_array_diff_key(INTERNAL_FUNCTION_PARAMETERS, int data_compare_ty
} }
} }
if (ok) { if (ok) {
(*((zval**)p->pData))->refcount++; Z_ADDREF_PP((zval**)p->pData);
zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL); zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
} }
} }

6
ext/standard/basic_functions.c
View file

@ -5418,7 +5418,7 @@ PHP_FUNCTION(register_shutdown_function)
} }
for (i = 0; i < shutdown_function_entry.arg_count; i++) { for (i = 0; i < shutdown_function_entry.arg_count; i++) {
shutdown_function_entry.arguments[i]->refcount++; Z_ADDREF_P(shutdown_function_entry.arguments[i]);
} }
zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL); zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL);
} }
@ -5994,7 +5994,7 @@ PHP_FUNCTION(register_tick_function)
} }
for (i = 0; i < tick_fe.arg_count; i++) { for (i = 0; i < tick_fe.arg_count; i++) {
tick_fe.arguments[i]->refcount++; Z_ADDREF_P(tick_fe.arguments[i]);
} }
zend_llist_add_element(BG(user_tick_functions), &tick_fe); zend_llist_add_element(BG(user_tick_functions), &tick_fe);
@ -6285,7 +6285,7 @@ static int copy_request_variable(void *pDest, int num_args, va_list args, zend_h
} }
zend_delete_global_variable(Z_STRVAL(new_key), Z_STRLEN(new_key) TSRMLS_CC); zend_delete_global_variable(Z_STRVAL(new_key), Z_STRLEN(new_key) TSRMLS_CC);
ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), Z_STRVAL(new_key), Z_STRLEN(new_key) + 1, *var, (*var)->refcount + 1, 0); ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), Z_STRVAL(new_key), Z_STRLEN(new_key) + 1, *var, Z_REFCOUNT_PP(var) + 1, 0);
zval_dtor(&new_key); zval_dtor(&new_key);
return 0; return 0;

2
ext/standard/php_filestat.h
View file

@ -62,7 +62,7 @@ PHP_FUNCTION(clearstatcache);
#define MAKE_LONG_ZVAL_INCREF(name, val)\ #define MAKE_LONG_ZVAL_INCREF(name, val)\
MAKE_STD_ZVAL(name); \ MAKE_STD_ZVAL(name); \
ZVAL_LONG(name, val); \ ZVAL_LONG(name, val); \
name->refcount++; Z_ADDREF_P(name);
#ifdef PHP_WIN32 #ifdef PHP_WIN32
#define S_IRUSR S_IREAD #define S_IRUSR S_IREAD

12
ext/standard/scanf.c
View file

@ -745,11 +745,11 @@ literal:
zend_uint refcount; zend_uint refcount;
current = args[objIndex++]; current = args[objIndex++];
refcount = (*current)->refcount; refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current ); zval_dtor( *current );
ZVAL_LONG( *current, (long)(string - baseString) ); ZVAL_LONG( *current, (long)(string - baseString) );
(*current)->refcount = refcount; Z_SET_REFCOUNT_PP(current, refcount);
(*current)->is_ref = 1; Z_SET_ISREF_PP(current);
} else { } else {
add_index_long(*return_value, objIndex++, string - baseString); add_index_long(*return_value, objIndex++, string - baseString);
} }
@ -869,11 +869,11 @@ literal:
zend_uint refcount; zend_uint refcount;
current = args[objIndex++]; current = args[objIndex++];
refcount = (*current)->refcount; refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current ); zval_dtor( *current );
ZVAL_STRINGL( *current, string, end-string, 1); ZVAL_STRINGL( *current, string, end-string, 1);
(*current)->refcount = refcount; Z_SET_REFCOUNT_PP(current, refcount);
(*current)->is_ref = 1; Z_SET_ISREF_PP(current);
} else { } else {
add_index_stringl( *return_value, objIndex++, string, end-string, 1); add_index_stringl( *return_value, objIndex++, string, end-string, 1);
} }

2
ext/standard/streamsfuncs.c
View file

@ -894,7 +894,7 @@ static int parse_context_params(php_stream_context *context, zval *params)
context->notifier = php_stream_notification_alloc(); context->notifier = php_stream_notification_alloc();
context->notifier->func = user_space_stream_notifier; context->notifier->func = user_space_stream_notifier;
context->notifier->ptr = *tmp; context->notifier->ptr = *tmp;
ZVAL_ADDREF(*tmp); Z_ADDREF_P(*tmp);
context->notifier->dtor = user_space_stream_notifier_dtor; context->notifier->dtor = user_space_stream_notifier_dtor;
} }
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) { if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) {

2
ext/standard/string.c
View file

@ -3569,7 +3569,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit
php_str_replace_in_subject(*search, *replace, subject_entry, result, case_sensitivity, (argc > 3) ? &count : NULL); php_str_replace_in_subject(*search, *replace, subject_entry, result, case_sensitivity, (argc > 3) ? &count : NULL);
} else { } else {
ALLOC_ZVAL(result); ALLOC_ZVAL(result);
ZVAL_ADDREF(*subject_entry); Z_ADDREF_P(*subject_entry);
COPY_PZVAL_TO_ZVAL(*result, *subject_entry); COPY_PZVAL_TO_ZVAL(*result, *subject_entry);
} }
/* Add to return array */ /* Add to return array */

4
ext/standard/user_filters.c
View file

@ -335,8 +335,8 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
/* create the object */ /* create the object */
ALLOC_ZVAL(obj); ALLOC_ZVAL(obj);
object_init_ex(obj, fdat->ce); object_init_ex(obj, fdat->ce);
ZVAL_REFCOUNT(obj) = 1; Z_SET_REFCOUNT_P(obj, 1);
PZVAL_IS_REF(obj) = 1; Z_SET_ISREF_P(obj);
/* filtername */ /* filtername */
add_property_string(obj, "filtername", (char*)filtername, 1); add_property_string(obj, "filtername", (char*)filtername, 1);

10
ext/standard/var.c
View file

@ -35,8 +35,7 @@
#include "basic_functions.h" #include "basic_functions.h"
#include "php_incomplete_class.h" #include "php_incomplete_class.h"
#define COMMON ((*struc)->is_ref ? "&" : "") #define COMMON (Z_ISREF_PP(struc) ? "&" : "")
#define Z_REFCOUNT_PP(a) ((*a)->refcount)
/* }}} */ /* }}} */
@ -269,7 +268,8 @@ PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC)
php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc)); php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc));
break; break;
case IS_DOUBLE: case IS_DOUBLE:
php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc)); php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc),
Z_REFCOUNT_PP(struc));
break; break;
case IS_STRING: case IS_STRING:
php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc)); php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
@ -500,7 +500,7 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old
} }
if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) { if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
if (!var->is_ref) { if (!Z_ISREF_P(var)) {
/* we still need to bump up the counter, since non-refs will /* we still need to bump up the counter, since non-refs will
be counted separately by unserializer */ be counted separately by unserializer */
var_no = -1; var_no = -1;
@ -648,7 +648,7 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
if (var_hash if (var_hash
&& php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) { && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
if(struc->is_ref) { if(Z_ISREF_P(struc)) {
smart_str_appendl(buf, "R:", 2); smart_str_appendl(buf, "R:", 2);
smart_str_append_long(buf, *var_already); smart_str_append_long(buf, *var_already);
smart_str_appendc(buf, ';'); smart_str_appendc(buf, ';');

10
ext/standard/var_unserializer.c
View file

@ -76,7 +76,7 @@ static inline void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
prev->next = var_hash; prev->next = var_hash;
} }
(*rval)->refcount++; Z_ADDREF_PP(rval);
var_hash->data[var_hash->used_slots++] = *rval; var_hash->data[var_hash->used_slots++] = *rval;
} }
@ -1096,8 +1096,8 @@ yy91:
zval_ptr_dtor(rval); zval_ptr_dtor(rval);
} }
*rval = *rval_ref; *rval = *rval_ref;
(*rval)->refcount++; Z_ADDREF_PP(rval);
(*rval)->is_ref = 0; Z_UNSET_ISREF_PP(rval);
return 1; return 1;
} }
@ -1140,8 +1140,8 @@ yy97:
zval_ptr_dtor(rval); zval_ptr_dtor(rval);
} }
*rval = *rval_ref; *rval = *rval_ref;
(*rval)->refcount++; Z_ADDREF_PP(rval);
(*rval)->is_ref = 1; Z_SET_ISREF_PP(rval);
return 1; return 1;
} }

10
ext/standard/var_unserializer.re
View file

@ -74,7 +74,7 @@ static inline void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
prev->next = var_hash; prev->next = var_hash;
} }
(*rval)->refcount++; Z_ADDREF_PP(rval);
var_hash->data[var_hash->used_slots++] = *rval; var_hash->data[var_hash->used_slots++] = *rval;
} }
@ -418,8 +418,8 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
zval_ptr_dtor(rval); zval_ptr_dtor(rval);
} }
*rval = *rval_ref; *rval = *rval_ref;
(*rval)->refcount++; Z_ADDREF_PP(rval);
(*rval)->is_ref = 1; Z_SET_ISREF_PP(rval);
return 1; return 1;
} }
@ -441,8 +441,8 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
zval_ptr_dtor(rval); zval_ptr_dtor(rval);
} }
*rval = *rval_ref; *rval = *rval_ref;
(*rval)->refcount++; Z_ADDREF_PP(rval);
(*rval)->is_ref = 0; Z_UNSET_ISREF_PP(rval);
return 1; return 1;
} }

6
ext/sybase/php_sybase_db.c
View file

@ -1053,7 +1053,7 @@ PHP_FUNCTION(sybase_fetch_row)
array_init(return_value); array_init(return_value);
for (i=0; i<result->num_fields; i++) { for (i=0; i<result->num_fields; i++) {
ZVAL_ADDREF(result->data[result->cur_row][i]); Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL); zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
} }
result->cur_row++; result->cur_row++;
@ -1087,9 +1087,9 @@ static void php_sybase_fetch_hash(INTERNAL_FUNCTION_PARAMETERS)
array_init(return_value); array_init(return_value);
for (i=0; i<result->num_fields; i++) { for (i=0; i<result->num_fields; i++) {
ZVAL_ADDREF(result->data[result->cur_row][i]); Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL); zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
ZVAL_ADDREF(result->data[result->cur_row][i]); Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_update(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL); zend_hash_update(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
} }
result->cur_row++; result->cur_row++;

4
ext/tidy/tidy.c
View file

@ -658,8 +658,8 @@ static zval * tidy_instanciate(zend_class_entry *pce, zval *object TSRMLS_DC)
Z_TYPE_P(object) = IS_OBJECT; Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce); object_init_ex(object, pce);
object->refcount = 1; Z_SET_REFCOUNT_P(object, 1);
object->is_ref = 1; Z_SET_ISREF_P(object);
return object; return object;
} }

2
ext/xmlreader/php_xmlreader.c
View file

@ -173,7 +173,7 @@ zval *xmlreader_read_property(zval *object, zval *member, int type TSRMLS_DC)
ret = xmlreader_property_reader(obj, hnd, &retval TSRMLS_CC); ret = xmlreader_property_reader(obj, hnd, &retval TSRMLS_CC);
if (ret == SUCCESS) { if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */ /* ensure we're creating a temporary variable */
retval->refcount = 0; Z_SET_REFCOUNT_P(retval, 0);
} else { } else {
retval = EG(uninitialized_zval_ptr); retval = EG(uninitialized_zval_ptr);
} }

2
ext/xsl/xsltprocessor.c
View file

@ -669,7 +669,7 @@ PHP_FUNCTION(xsl_xsltprocessor_set_parameter)
} }
ALLOC_ZVAL(new_string); ALLOC_ZVAL(new_string);
ZVAL_ADDREF(*entry); Z_ADDREF_PP(entry);
COPY_PZVAL_TO_ZVAL(*new_string, *entry); COPY_PZVAL_TO_ZVAL(*new_string, *entry);
zend_hash_update(intern->parameter, string_key, string_key_len, &new_string, sizeof(zval*), NULL); zend_hash_update(intern->parameter, string_key, string_key_len, &new_string, sizeof(zval*), NULL);

6
ext/zip/php_zip.c
View file

@ -433,7 +433,7 @@ static zval* php_zip_read_property(zval *object, zval *member, int type TSRMLS_D
ret = php_zip_property_reader(obj, hnd, &retval, 1 TSRMLS_CC); ret = php_zip_property_reader(obj, hnd, &retval, 1 TSRMLS_CC);
if (ret == SUCCESS) { if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */ /* ensure we're creating a temporary variable */
retval->refcount = 0; Z_SET_REFCOUNT_P(retval, 0);
} else { } else {
retval = EG(uninitialized_zval_ptr); retval = EG(uninitialized_zval_ptr);
} }
@ -477,8 +477,8 @@ static int php_zip_has_property(zval *object, zval *member, int type TSRMLS_DC)
if (type == 2) { if (type == 2) {
retval = 1; retval = 1;
} else if (php_zip_property_reader(obj, hnd, &tmp, 1 TSRMLS_CC) == SUCCESS) { } else if (php_zip_property_reader(obj, hnd, &tmp, 1 TSRMLS_CC) == SUCCESS) {
tmp->refcount = 1; Z_SET_REFCOUNT_P(tmp, 1);
tmp->is_ref = 0; Z_UNSET_ISREF_P(tmp);
if (type == 1) { if (type == 1) {
retval = zend_is_true(tmp); retval = zend_is_true(tmp);
} else if (type == 0) { } else if (type == 0) {

10
main/output.c
View file

@ -227,8 +227,8 @@ PHPAPI void php_end_ob_buffer(zend_bool send_buffer, zend_bool just_flush TSRMLS
ALLOC_INIT_ZVAL(orig_buffer); ALLOC_INIT_ZVAL(orig_buffer);
ZVAL_STRINGL(orig_buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1); ZVAL_STRINGL(orig_buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
orig_buffer->refcount=2; /* don't let call_user_function() destroy our buffer */ Z_SET_REFCOUNT_P(orig_buffer, 2); /* don't let call_user_function() destroy our buffer */
orig_buffer->is_ref=1; Z_SET_ISREF_P(orig_buffer);
ALLOC_INIT_ZVAL(z_status); ALLOC_INIT_ZVAL(z_status);
ZVAL_LONG(z_status, status); ZVAL_LONG(z_status, status);
@ -248,8 +248,8 @@ PHPAPI void php_end_ob_buffer(zend_bool send_buffer, zend_bool just_flush TSRMLS
if (!just_flush) { if (!just_flush) {
zval_ptr_dtor(&OG(active_ob_buffer).output_handler); zval_ptr_dtor(&OG(active_ob_buffer).output_handler);
} }
orig_buffer->refcount -=2; Z_SET_REFCOUNT_P(orig_buffer, Z_REFCOUNT_P(orig_buffer) - 2);
if (orig_buffer->refcount <= 0) { /* free the zval */ if (Z_REFCOUNT_P(orig_buffer) <= 0) { /* free the zval */
zval_dtor(orig_buffer); zval_dtor(orig_buffer);
FREE_ZVAL(orig_buffer); FREE_ZVAL(orig_buffer);
} }
@ -510,7 +510,7 @@ static int php_ob_init(uint initial_size, uint block_size, zval *output_handler,
/* do we have array(object,method) */ /* do we have array(object,method) */
if (zend_is_callable(output_handler, 0, &handler_name)) { if (zend_is_callable(output_handler, 0, &handler_name)) {
SEPARATE_ZVAL(&output_handler); SEPARATE_ZVAL(&output_handler);
output_handler->refcount++; Z_ADDREF_P(output_handler);
result = php_ob_init_named(initial_size, block_size, handler_name, output_handler, chunk_size, erase TSRMLS_CC); result = php_ob_init_named(initial_size, block_size, handler_name, output_handler, chunk_size, erase TSRMLS_CC);
efree(handler_name); efree(handler_name);
} else { } else {

4
main/php_ini.c
View file

@ -207,7 +207,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t
copy = *arg2; copy = *arg2;
zval_copy_ctor(&copy); zval_copy_ctor(&copy);
copy.refcount = 0; Z_SET_REFCOUNT(copy, 0);
zend_llist_add_element(&extension_lists.functions, &copy); zend_llist_add_element(&extension_lists.functions, &copy);
} else if (!strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */ } else if (!strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */
char *extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2)); char *extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
@ -573,7 +573,7 @@ int php_init_config(TSRMLS_D)
Z_STRLEN(tmp) = strlen(fh.filename); Z_STRLEN(tmp) = strlen(fh.filename);
Z_STRVAL(tmp) = zend_strndup(fh.filename, Z_STRLEN(tmp)); Z_STRVAL(tmp) = zend_strndup(fh.filename, Z_STRLEN(tmp));
Z_TYPE(tmp) = IS_STRING; Z_TYPE(tmp) = IS_STRING;
tmp.refcount = 0; Z_SET_REFCOUNT(tmp, 0);
zend_hash_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path"), (void *) &tmp, sizeof(zval), NULL); zend_hash_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path"), (void *) &tmp, sizeof(zval), NULL);
if (php_ini_opened_path) { if (php_ini_opened_path) {

28
main/php_variables.c
View file

@ -517,14 +517,14 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
Z_TYPE_P(argc) = IS_LONG; Z_TYPE_P(argc) = IS_LONG;
if (PG(register_globals) || SG(request_info).argc) { if (PG(register_globals) || SG(request_info).argc) {
arr->refcount++; Z_ADDREF_P(arr);
argc->refcount++; Z_ADDREF_P(argc);
zend_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
zend_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); zend_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
} }
if (track_vars_array) { if (track_vars_array) {
arr->refcount++; Z_ADDREF_P(arr);
argc->refcount++; Z_ADDREF_P(argc);
zend_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); zend_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
zend_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); zend_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
} }
@ -613,13 +613,13 @@ static void php_autoglobal_merge(HashTable *dest, HashTable *src TSRMLS_DC)
|| (key_type == HASH_KEY_IS_LONG && zend_hash_index_find(dest, num_key, (void **)&dest_entry) != SUCCESS) || (key_type == HASH_KEY_IS_LONG && zend_hash_index_find(dest, num_key, (void **)&dest_entry) != SUCCESS)
|| Z_TYPE_PP(dest_entry) != IS_ARRAY || Z_TYPE_PP(dest_entry) != IS_ARRAY
) { ) {
(*src_entry)->refcount++; Z_ADDREF_PP(src_entry);
if (key_type == HASH_KEY_IS_STRING) { if (key_type == HASH_KEY_IS_STRING) {
/* if register_globals is on and working with main symbol table, prevent overwriting of GLOBALS */ /* if register_globals is on and working with main symbol table, prevent overwriting of GLOBALS */
if (!globals_check || string_key_len != sizeof("GLOBALS") || memcmp(string_key, "GLOBALS", sizeof("GLOBALS") - 1)) { if (!globals_check || string_key_len != sizeof("GLOBALS") || memcmp(string_key, "GLOBALS", sizeof("GLOBALS") - 1)) {
zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL); zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
} else { } else {
(*src_entry)->refcount--; Z_DELREF_PP(src_entry);
} }
} else { } else {
zend_hash_index_update(dest, num_key, src_entry, sizeof(zval *), NULL); zend_hash_index_update(dest, num_key, src_entry, sizeof(zval *), NULL);
@ -738,11 +738,11 @@ int php_hash_environment(TSRMLS_D)
INIT_PZVAL(PG(http_globals)[i]); INIT_PZVAL(PG(http_globals)[i]);
} }
PG(http_globals)[i]->refcount++; Z_ADDREF_P(PG(http_globals)[i]);
zend_hash_update(&EG(symbol_table), auto_global_records[i].name, auto_global_records[i].name_len, &PG(http_globals)[i], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), auto_global_records[i].name, auto_global_records[i].name_len, &PG(http_globals)[i], sizeof(zval *), NULL);
if (PG(register_long_arrays)) { if (PG(register_long_arrays)) {
zend_hash_update(&EG(symbol_table), auto_global_records[i].long_name, auto_global_records[i].long_name_len, &PG(http_globals)[i], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), auto_global_records[i].long_name, auto_global_records[i].long_name_len, &PG(http_globals)[i], sizeof(zval *), NULL);
PG(http_globals)[i]->refcount++; Z_ADDREF_P(PG(http_globals)[i]);
} }
} }
@ -767,8 +767,8 @@ static zend_bool php_auto_globals_create_server(char *name, uint name_len TSRMLS
if (zend_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS && if (zend_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS &&
zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) { zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) {
(*argc)->refcount++; Z_ADDREF_PP(argc);
(*argv)->refcount++; Z_ADDREF_PP(argv);
zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL); zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL);
zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL); zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL);
} }
@ -789,11 +789,11 @@ static zend_bool php_auto_globals_create_server(char *name, uint name_len TSRMLS
} }
zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL);
PG(http_globals)[TRACK_VARS_SERVER]->refcount++; Z_ADDREF_P(PG(http_globals)[TRACK_VARS_SERVER]);
if (PG(register_long_arrays)) { if (PG(register_long_arrays)) {
zend_hash_update(&EG(symbol_table), "HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS"), &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), "HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS"), &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL);
PG(http_globals)[TRACK_VARS_SERVER]->refcount++; Z_ADDREF_P(PG(http_globals)[TRACK_VARS_SERVER]);
} }
return 0; /* don't rearm */ return 0; /* don't rearm */
@ -815,11 +815,11 @@ static zend_bool php_auto_globals_create_env(char *name, uint name_len TSRMLS_DC
} }
zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL);
PG(http_globals)[TRACK_VARS_ENV]->refcount++; Z_ADDREF_P(PG(http_globals)[TRACK_VARS_ENV]);
if (PG(register_long_arrays)) { if (PG(register_long_arrays)) {
zend_hash_update(&EG(symbol_table), "HTTP_ENV_VARS", sizeof("HTTP_ENV_VARS"), &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL); zend_hash_update(&EG(symbol_table), "HTTP_ENV_VARS", sizeof("HTTP_ENV_VARS"), &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL);
PG(http_globals)[TRACK_VARS_ENV]->refcount++; Z_ADDREF_P(PG(http_globals)[TRACK_VARS_ENV]);
} }
return 0; /* don't rearm */ return 0; /* don't rearm */

32
main/streams/userspace.c
View file

@ -242,8 +242,8 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, char *filena
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(us->object); ALLOC_ZVAL(us->object);
object_init_ex(us->object, uwrap->ce); object_init_ex(us->object, uwrap->ce);
ZVAL_REFCOUNT(us->object) = 1; Z_SET_REFCOUNT_P(us->object, 1);
PZVAL_IS_REF(us->object) = 1; Z_SET_ISREF_P(us->object);
if (uwrap->ce->constructor) { if (uwrap->ce->constructor) {
zend_fcall_info fci; zend_fcall_info fci;
@ -305,8 +305,8 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, char *filena
args[2] = &zoptions; args[2] = &zoptions;
MAKE_STD_ZVAL(zopened); MAKE_STD_ZVAL(zopened);
ZVAL_REFCOUNT(zopened) = 1; Z_SET_REFCOUNT_P(zopened, 1);
PZVAL_IS_REF(zopened) = 1; Z_SET_ISREF_P(zopened);
ZVAL_NULL(zopened); ZVAL_NULL(zopened);
args[3] = &zopened; args[3] = &zopened;
@ -380,8 +380,8 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, char *filen
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(us->object); ALLOC_ZVAL(us->object);
object_init_ex(us->object, uwrap->ce); object_init_ex(us->object, uwrap->ce);
ZVAL_REFCOUNT(us->object) = 1; Z_SET_REFCOUNT_P(us->object, 1);
PZVAL_IS_REF(us->object) = 1; Z_SET_ISREF_P(us->object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);
@ -961,8 +961,8 @@ static int user_wrapper_unlink(php_stream_wrapper *wrapper, char *url, int optio
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(object); ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce); object_init_ex(object, uwrap->ce);
ZVAL_REFCOUNT(object) = 1; Z_SET_REFCOUNT_P(object, 1);
PZVAL_IS_REF(object) = 1; Z_SET_ISREF_P(object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);
@ -1019,8 +1019,8 @@ static int user_wrapper_rename(php_stream_wrapper *wrapper, char *url_from, char
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(object); ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce); object_init_ex(object, uwrap->ce);
ZVAL_REFCOUNT(object) = 1; Z_SET_REFCOUNT_P(object, 1);
PZVAL_IS_REF(object) = 1; Z_SET_ISREF_P(object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);
@ -1082,8 +1082,8 @@ static int user_wrapper_mkdir(php_stream_wrapper *wrapper, char *url, int mode,
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(object); ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce); object_init_ex(object, uwrap->ce);
ZVAL_REFCOUNT(object) = 1; Z_SET_REFCOUNT_P(object, 1);
PZVAL_IS_REF(object) = 1; Z_SET_ISREF_P(object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);
@ -1151,8 +1151,8 @@ static int user_wrapper_rmdir(php_stream_wrapper *wrapper, char *url, int option
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(object); ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce); object_init_ex(object, uwrap->ce);
ZVAL_REFCOUNT(object) = 1; Z_SET_REFCOUNT_P(object, 1);
PZVAL_IS_REF(object) = 1; Z_SET_ISREF_P(object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);
@ -1215,8 +1215,8 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, char *url, int fla
/* create an instance of our class */ /* create an instance of our class */
ALLOC_ZVAL(object); ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce); object_init_ex(object, uwrap->ce);
ZVAL_REFCOUNT(object) = 1; Z_SET_REFCOUNT_P(object, 1);
PZVAL_IS_REF(object) = 1; Z_SET_ISREF_P(object);
if (context) { if (context) {
MAKE_STD_ZVAL(zcontext); MAKE_STD_ZVAL(zcontext);