Use macros to update specific parts of GC_TYPE_INFO() (direct assignments to GC_TYPE...

diff --git a/Zend/zend_gc.c b/Zend/zend_gc.c
index eb7f0ab41458574c6729a6f6683e15cc6b844b1e..beb3bcd326d7643a65485384c714819a0ff0bc4e 100644 (file)
--- a/Zend/zend_gc.c
+++ b/Zend/zend_gc.c
@@ -91,14 +91,6 @@
        ((v) & ~GC_COLOR)
 #define GC_INFO_GET_COLOR(v) \
        (((zend_uintptr_t)(v)) & GC_COLOR)
-#define GC_INFO_SET_ADDRESS(v, a) \
-       do {(v) = ((v) & GC_COLOR) | (a);} while (0)
-#define GC_INFO_SET_COLOR(v, c) \
-       do {(v) = ((v) & ~GC_COLOR) | (c);} while (0)
-#define GC_INFO_SET_BLACK(v) \
-       do {(v) = (v) & ~GC_COLOR;} while (0)
-#define GC_INFO_SET_PURPLE(v) \
-       do {(v) = (v) | GC_COLOR;} while (0)
 
 /* one (0) is reserved */
 #define GC_ROOT_BUFFER_MAX_ENTRIES 10001
@@ -192,16 +184,26 @@ static zend_gc_globals gc_globals;
 # define GC_TRACE(str)
 #endif
 
-#define GC_REF_SET_ADDRESS(ref, a) \
-       GC_INFO_SET_ADDRESS(GC_INFO(ref), a)
+#define GC_REF_SET_INFO(ref, info) do { \
+               GC_TYPE_INFO(ref) = ((info) << GC_INFO_SHIFT) | \
+                       (GC_TYPE_INFO(ref) & (GC_TYPE_MASK | GC_FLAGS_MASK)); \
+       } while (0)
+#define GC_REF_SET_ADDRESS(ref, a) do {\
+               GC_TYPE_INFO(ref) = ((info) << GC_INFO_SHIFT) | \
+                       (GC_TYPE_INFO(ref) & (GC_TYPE_MASK | GC_FLAGS_MASK | (GC_COLOR << GC_INFO_SHIFT))); \
+       } while (0)
 #define GC_REF_GET_COLOR(ref) \
        GC_INFO_GET_COLOR(GC_INFO(ref))
-#define GC_REF_SET_COLOR(ref, c) \
-       do { GC_TRACE_SET_COLOR(ref, c); GC_INFO_SET_COLOR(GC_INFO(ref), c); } while (0)
-#define GC_REF_SET_BLACK(ref) \
-       do { GC_TRACE_SET_COLOR(ref, GC_BLACK); GC_INFO_SET_BLACK(GC_INFO(ref)); } while (0)
-#define GC_REF_SET_PURPLE(ref) \
-       do { GC_TRACE_SET_COLOR(ref, GC_PURPLE); GC_INFO_SET_PURPLE(GC_INFO(ref)); } while (0)
+#define GC_REF_SET_COLOR(ref, c) do { \
+               GC_TYPE_INFO(ref) = ((c) << GC_INFO_SHIFT) | \
+                       (GC_TYPE_INFO(ref) & (GC_TYPE_MASK | GC_FLAGS_MASK | ~(GC_COLOR << GC_INFO_SHIFT))); \
+       } while (0)
+#define GC_REF_SET_BLACK(ref) do { \
+               GC_TYPE_INFO(ref) &= ~(GC_COLOR << GC_INFO_SHIFT); \
+       } while (0)
+#define GC_REF_SET_PURPLE(ref) do { \
+               GC_TYPE_INFO(ref) |= (GC_COLOR << GC_INFO_SHIFT); \
+       } while (0)
 
 #if ZEND_GC_DEBUG > 1
 static const char *gc_color_name(uint32_t color) {
@@ -402,7 +404,7 @@ ZEND_API void ZEND_FASTCALL gc_possible_root(zend_refcounted *ref)
        }
 
        GC_TRACE_SET_COLOR(ref, GC_PURPLE);
-       GC_INFO(ref) = (newRoot - GC_G(buf)) | GC_PURPLE;
+       GC_REF_SET_INFO(ref, (newRoot - GC_G(buf)) | GC_PURPLE);
        newRoot->ref = ref;
 
        newRoot->next = GC_G(roots).next;
@@ -453,7 +455,7 @@ ZEND_API void ZEND_FASTCALL gc_remove_from_buffer(zend_refcounted *ref)
        if (GC_REF_GET_COLOR(ref) != GC_BLACK) {
                GC_TRACE_SET_COLOR(ref, GC_PURPLE);
        }
-       GC_INFO(ref) = 0;
+       GC_REF_SET_INFO(ref, 0);
 
        /* updete next root that is going to be freed */
        if (GC_G(next_to_free) == root) {
@@ -797,7 +799,7 @@ static void gc_add_garbage(zend_refcounted *ref)
                GC_G(unused) = buf->prev;
 #if 1
                /* optimization: color is already GC_BLACK (0) */
-               GC_INFO(ref) = buf - GC_G(buf);
+               GC_REF_SET_INFO(ref, buf - GC_G(buf));
 #else
                GC_REF_SET_ADDRESS(ref, buf - GC_G(buf));
 #endif
@@ -806,7 +808,7 @@ static void gc_add_garbage(zend_refcounted *ref)
                GC_G(first_unused)++;
 #if 1
                /* optimization: color is already GC_BLACK (0) */
-               GC_INFO(ref) = buf - GC_G(buf);
+               GC_REF_SET_INFO(ref, buf - GC_G(buf));
 #else
                GC_REF_SET_ADDRESS(ref, buf - GC_G(buf));
 #endif
@@ -824,7 +826,7 @@ static void gc_add_garbage(zend_refcounted *ref)
                buf = GC_G(additional_buffer)->buf + GC_G(additional_buffer)->used;
 #if 1
                /* optimization: color is already GC_BLACK (0) */
-               GC_INFO(ref) = GC_ROOT_BUFFER_MAX_ENTRIES + GC_G(additional_buffer)->used;
+               GC_REF_SET_INFO(ref, GC_ROOT_BUFFER_MAX_ENTRIES + GC_G(additional_buffer)->used);
 #else
                GC_REF_SET_ADDRESS(ref, GC_ROOT_BUFFER_MAX_ENTRIES) + GC_G(additional_buffer)->used;
 #endif
@@ -990,7 +992,7 @@ static int gc_collect_roots(uint32_t *flags)
                        } else {
                                gc_remove_from_additional_roots(current);
                        }
-                       GC_INFO(current->ref) = 0; /* reset GC_ADDRESS() and keep GC_BLACK */
+                       GC_REF_SET_INFO(current->ref, 0); /* reset GC_ADDRESS() and keep GC_BLACK */
                }
                current = next;
        }
@@ -1042,7 +1044,7 @@ tail_call:
                        } else {
                                gc_remove_from_additional_roots(root);
                        }
-                       GC_INFO(ref) = 0;
+                       GC_REF_SET_INFO(ref, 0);
                        root = NULL;
                } else {
                        GC_REMOVE_FROM_BUFFER(ref);
@@ -1210,7 +1212,7 @@ ZEND_API int zend_gc_collect_cycles(void)
 
                                        if (!(OBJ_FLAGS(obj) & IS_OBJ_DESTRUCTOR_CALLED)) {
                                                GC_TRACE_REF(obj, "calling destructor");
-                                               OBJ_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                               GC_ADD_FLAGS(obj, IS_OBJ_DESTRUCTOR_CALLED);
                                                if (obj->handlers->dtor_obj
                                                 && (obj->handlers->dtor_obj != zend_objects_destroy_object
                                                  || obj->ce->destructor)) {
@@ -1246,9 +1248,10 @@ ZEND_API int zend_gc_collect_cycles(void)
                                zend_object *obj = (zend_object*)p;
 
                                EG(objects_store).object_buckets[obj->handle] = SET_OBJ_INVALID(obj);
-                               GC_TYPE(obj) = IS_NULL;
+                               GC_TYPE_INFO(obj) = IS_NULL |
+                                       (GC_TYPE_INFO(obj) & ~GC_TYPE_MASK);
                                if (!(OBJ_FLAGS(obj) & IS_OBJ_FREE_CALLED)) {
-                                       OBJ_FLAGS(obj) |= IS_OBJ_FREE_CALLED;
+                                       GC_ADD_FLAGS(obj, IS_OBJ_FREE_CALLED);
                                        if (obj->handlers->free_obj) {
                                                GC_ADDREF(obj);
                                                obj->handlers->free_obj(obj);
@@ -1261,7 +1264,8 @@ ZEND_API int zend_gc_collect_cycles(void)
                        } else if (GC_TYPE(p) == IS_ARRAY) {
                                zend_array *arr = (zend_array*)p;
 
-                               GC_TYPE(arr) = IS_NULL;
+                               GC_TYPE_INFO(arr) = IS_NULL |
+                                       (GC_TYPE_INFO(arr) & ~GC_TYPE_MASK);
 
                                /* GC may destroy arrays with rc>1. This is valid and safe. */
                                HT_ALLOW_COW_VIOLATION(arr);

diff --git a/Zend/zend_gc.h b/Zend/zend_gc.h
index f045026ccfd235c7c46bbadd19d3cdb203fcf079..f5c7b63ffd036342d46bdcfd8f74938fb69dfc2f 100644 (file)
--- a/Zend/zend_gc.h
+++ b/Zend/zend_gc.h
@@ -51,7 +51,7 @@ END_EXTERN_C()
 
 static zend_always_inline void gc_check_possible_root(zend_refcounted *ref)
 {
-       if (GC_TYPE(ref) == IS_REFERENCE) {
+       if (GC_TYPE_INFO(ref) == IS_REFERENCE) {
                zval *zv = &((zend_reference*)ref)->val;
 
                if (!Z_REFCOUNTED_P(zv)) {

diff --git a/Zend/zend_objects_API.c b/Zend/zend_objects_API.c
index 633b48a2cbd2ccc8b79902ed910446fd2a3851c6..3e0baaa6913b6b9168e8abfce85629224b68dca6 100644 (file)
--- a/Zend/zend_objects_API.c
+++ b/Zend/zend_objects_API.c
@@ -49,7 +49,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_call_destructors(zend_objects_sto
                        zend_object *obj = objects->object_buckets[i];
                        if (IS_OBJ_VALID(obj)) {
                                if (!(OBJ_FLAGS(obj) & IS_OBJ_DESTRUCTOR_CALLED)) {
-                                       OBJ_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                       GC_ADD_FLAGS(obj, IS_OBJ_DESTRUCTOR_CALLED);
 
                                        if (obj->handlers->dtor_obj
                                         && (obj->handlers->dtor_obj != zend_objects_destroy_object
@@ -74,7 +74,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_mark_destructed(zend_objects_stor
                        zend_object *obj = *obj_ptr;
 
                        if (IS_OBJ_VALID(obj)) {
-                               OBJ_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+                               GC_ADD_FLAGS(obj, IS_OBJ_DESTRUCTOR_CALLED);
                        }
                        obj_ptr++;
                } while (obj_ptr != end);
@@ -99,7 +99,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_free_object_storage(zend_objects_
                        obj = *obj_ptr;
                        if (IS_OBJ_VALID(obj)) {
                                if (!(OBJ_FLAGS(obj) & IS_OBJ_FREE_CALLED)) {
-                                       OBJ_FLAGS(obj) |= IS_OBJ_FREE_CALLED;
+                                       GC_ADD_FLAGS(obj, IS_OBJ_FREE_CALLED);
                                        if (obj->handlers->free_obj && obj->handlers->free_obj != zend_object_std_dtor) {
                                                GC_ADDREF(obj);
                                                obj->handlers->free_obj(obj);
@@ -114,7 +114,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_free_object_storage(zend_objects_
                        obj = *obj_ptr;
                        if (IS_OBJ_VALID(obj)) {
                                if (!(OBJ_FLAGS(obj) & IS_OBJ_FREE_CALLED)) {
-                                       OBJ_FLAGS(obj) |= IS_OBJ_FREE_CALLED;
+                                       GC_ADD_FLAGS(obj, IS_OBJ_FREE_CALLED);
                                        if (obj->handlers->free_obj) {
                                                GC_ADDREF(obj);
                                                obj->handlers->free_obj(obj);
@@ -165,7 +165,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_del(zend_object *object) /* {{{ *
        ZEND_ASSERT(GC_REFCOUNT(object) == 0);
 
        if (!(OBJ_FLAGS(object) & IS_OBJ_DESTRUCTOR_CALLED)) {
-               OBJ_FLAGS(object) |= IS_OBJ_DESTRUCTOR_CALLED;
+               GC_ADD_FLAGS(object, IS_OBJ_DESTRUCTOR_CALLED);
 
                if (object->handlers->dtor_obj
                 && (object->handlers->dtor_obj != zend_objects_destroy_object
@@ -182,7 +182,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_del(zend_object *object) /* {{{ *
 
                EG(objects_store).object_buckets[handle] = SET_OBJ_INVALID(object);
                if (!(OBJ_FLAGS(object) & IS_OBJ_FREE_CALLED)) {
-                       OBJ_FLAGS(object) |= IS_OBJ_FREE_CALLED;
+                       GC_ADD_FLAGS(object, IS_OBJ_FREE_CALLED);
                        if (object->handlers->free_obj) {
                                GC_ADDREF(object);
                                object->handlers->free_obj(object);

diff --git a/Zend/zend_objects_API.h b/Zend/zend_objects_API.h
index a581c4b2090f714c5b47b845c80b229fbac66baa..5a9e3a5041cc00f8e8f1521434b5a4bd94713c5e 100644 (file)
--- a/Zend/zend_objects_API.h
+++ b/Zend/zend_objects_API.h
@@ -62,7 +62,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_store_del(zend_object *object);
 /* Called when the ctor was terminated by an exception */
 static zend_always_inline void zend_object_store_ctor_failed(zend_object *obj)
 {
-       OBJ_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+       GC_ADD_FLAGS(obj, IS_OBJ_DESTRUCTOR_CALLED);
 }
 
 #define ZEND_OBJECTS_STORE_HANDLERS 0, zend_object_std_dtor, zend_objects_destroy_object, zend_objects_clone_obj

diff --git a/Zend/zend_string.c b/Zend/zend_string.c
index 23d6d245febc36b6384e62e54fb315c71941528b..9172751d9bc207352d8d2bbcac12f82c65d9284e 100644 (file)
--- a/Zend/zend_string.c
+++ b/Zend/zend_string.c
@@ -166,7 +166,7 @@ static zend_always_inline zend_string *zend_add_interned_string(zend_string *str
        zval val;
 
        GC_SET_REFCOUNT(str, 1);
-       GC_FLAGS(str) |= IS_STR_INTERNED | flags;
+       GC_ADD_FLAGS(str, IS_STR_INTERNED | flags);
 
        ZVAL_INTERNED_STR(&val, str);
 

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index e5ea3687649dd517da8cc4ca4978b63f2e5d22ac..6119083376c83bfcef4bc42b95d71831e89f39bb 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -446,10 +446,35 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define GC_ADDREF_EX(p, rc)                    zend_gc_addref_ex(&(p)->gc, rc)
 #define GC_DELREF_EX(p, rc)                    zend_gc_delref_ex(&(p)->gc, rc)
 
-#define GC_TYPE(p)                                     (p)->gc.u.v.type
-#define GC_FLAGS(p)                                    (p)->gc.u.v.flags
-#define GC_INFO(p)                                     (p)->gc.u.v.gc_info
+#define GC_TYPE_MASK                           0x000000ff
+#define GC_FLAGS_MASK                          0x0000ff00
+#define GC_INFO_MASK                           0xffff0000
+#define GC_FLAGS_SHIFT                         8
+#define GC_INFO_SHIFT                          16
+
+static zend_always_inline zend_uchar zval_gc_type(uint32_t gc_type_info) {
+       return (gc_type_info & GC_TYPE_MASK);
+}
+
+static zend_always_inline zend_uchar zval_gc_flags(uint32_t gc_type_info) {
+       return (gc_type_info >> GC_FLAGS_SHIFT) & (GC_FLAGS_MASK >> GC_FLAGS_SHIFT);
+}
+
+static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
+       return (gc_type_info >> GC_INFO_SHIFT);
+}
+
 #define GC_TYPE_INFO(p)                                (p)->gc.u.type_info
+#define GC_TYPE(p)                                     zval_gc_type(GC_TYPE_INFO(p))
+#define GC_FLAGS(p)                                    zval_gc_flags(GC_TYPE_INFO(p))
+#define GC_INFO(p)                                     zval_gc_info(GC_TYPE_INFO(p))
+
+#define GC_ADD_FLAGS(p, flags) do { \
+               GC_TYPE_INFO(p) |= (flags) << GC_FLAGS_SHIFT; \
+       } while (0)
+#define GC_DEL_FLAGS(p, flags) do { \
+               GC_TYPE_INFO(p) &= ~((flags) << GC_FLAGS_SHIFT); \
+       } while (0)
 
 #define Z_GC_TYPE(zval)                                GC_TYPE(Z_COUNTED(zval))
 #define Z_GC_TYPE_P(zval_p)                    Z_GC_TYPE(*(zval_p))
@@ -462,10 +487,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_GC_TYPE_INFO(zval)           GC_TYPE_INFO(Z_COUNTED(zval))
 #define Z_GC_TYPE_INFO_P(zval_p)       Z_GC_TYPE_INFO(*(zval_p))
 
-#define GC_FLAGS_SHIFT                         8
-#define GC_INFO_SHIFT                          16
-#define GC_INFO_MASK                           0xffff0000
-
 /* zval.value->gc.u.v.flags (common flags) */
 #define GC_COLLECTABLE                         (1<<0)
 #define GC_PROTECTED                (1<<1) /* used for recursion detection */
@@ -517,11 +538,11 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
        (GC_FLAGS(p) & GC_PROTECTED)
 
 #define GC_PROTECT_RECURSION(p) do { \
-               GC_FLAGS(p) |= GC_PROTECTED; \
+               GC_ADD_FLAGS(p, GC_PROTECTED); \
        } while (0)
 
 #define GC_UNPROTECT_RECURSION(p) do { \
-               GC_FLAGS(p) &= ~GC_PROTECTED; \
+               GC_DEL_FLAGS(p, GC_PROTECTED); \
        } while (0)
 
 #define Z_IS_RECURSIVE(zval)        GC_IS_RECURSIVE(Z_COUNTED(zval))
@@ -914,7 +935,7 @@ extern ZEND_API zend_bool zend_rc_debug;
                } \
        } while (0)
 # define GC_MAKE_PERSISTENT_LOCAL(p) do { \
-               GC_FLAGS(p) |= GC_PERSISTENT_LOCAL; \
+               GC_ADD_FLAGS(p, GC_PERSISTENT_LOCAL); \
        } while (0)
 #else
 # define ZEND_RC_MOD_CHECK(p) \

diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index d9d2cdb4d1d77b346bbded4788a4c2bfa46614d1..12ce26b914ac02e25614dd2a28b82aaa8b93f563 100644 (file)
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -480,13 +480,7 @@ zend_string *accel_new_interned_string(zend_string *str)
        STRTAB_COLLISION(s) = *hash_slot;
        *hash_slot = STRTAB_STR_TO_POS(&ZCSG(interned_strings), s);
        GC_SET_REFCOUNT(s, 1);
-#if 1
-       /* optimized single assignment */
        GC_TYPE_INFO(s) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << GC_FLAGS_SHIFT);
-#else
-       GC_TYPE(s) = IS_STRING;
-       GC_FLAGS(s) = IS_STR_INTERNED | IS_STR_PERMANENT;
-#endif
        ZSTR_H(s) = h;
        ZSTR_LEN(s) = ZSTR_LEN(str);
        memcpy(ZSTR_VAL(s), ZSTR_VAL(str), ZSTR_LEN(s) + 1);

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index e48ccc22e80adcd29b2068c751b71609b3648145..f693669446ab3ad2f1e3e1986f4dabdd773cc9e5 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -118,8 +118,8 @@ static int zend_file_cache_flock(int fd, int type)
                                ZEND_ASSERT(IS_UNSERIALIZED(ptr)); \
                                /* script->corrupted shows if the script in SHM or not */ \
                                if (EXPECTED(script->corrupted)) { \
-                                       GC_FLAGS(ptr) |= IS_STR_INTERNED; \
-                                       GC_FLAGS(ptr) &= ~IS_STR_PERMANENT; \
+                                       GC_ADD_FLAGS(ptr, IS_STR_INTERNED); \
+                                       GC_DEL_FLAGS(ptr, IS_STR_PERMANENT); \
                                } \
                                (ptr) = (void*)((char*)(ptr) - (char*)script->mem); \
                        } \
@@ -134,10 +134,10 @@ static int zend_file_cache_flock(int fd, int type)
                                (ptr) = (void*)((char*)buf + (size_t)(ptr)); \
                                /* script->corrupted shows if the script in SHM or not */ \
                                if (EXPECTED(!script->corrupted)) { \
-                                       GC_FLAGS(ptr) |= IS_STR_INTERNED | IS_STR_PERMANENT; \
+                                       GC_ADD_FLAGS(ptr, IS_STR_INTERNED | IS_STR_PERMANENT); \
                                } else { \
-                                       GC_FLAGS(ptr) |= IS_STR_INTERNED; \
-                                       GC_FLAGS(ptr) &= ~IS_STR_PERMANENT; \
+                                       GC_ADD_FLAGS(ptr, IS_STR_INTERNED); \
+                                       GC_DEL_FLAGS(ptr, IS_STR_PERMANENT); \
                                } \
                        } \
                } \
@@ -241,8 +241,8 @@ static void *zend_file_cache_unserialize_interned(zend_string *str, int in_shm)
                }
        } else {
                ret = str;
-               GC_FLAGS(ret) |= IS_STR_INTERNED;
-               GC_FLAGS(ret) &= ~IS_STR_PERMANENT;
+               GC_ADD_FLAGS(ret, IS_STR_INTERNED);
+               GC_DEL_FLAGS(ret, IS_STR_PERMANENT);
        }
        return ret;
 }

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 9fc6da744fae4c25ef842a907b356aaa3253cd97..d433b75d0b5edea0da196887a0cb2896505e5250 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -36,13 +36,15 @@
 #ifdef HAVE_OPCACHE_FILE_CACHE
 #define zend_set_str_gc_flags(str) do { \
        if (ZCG(accel_directives).file_cache_only) { \
-               GC_FLAGS(str) = IS_STR_INTERNED; \
+               GC_TYPE_INFO(str) = IS_STRING | (IS_STR_INTERNED << GC_FLAGS_SHIFT); \
        } else { \
-               GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT; \
+               GC_TYPE_INFO(str) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << GC_FLAGS_SHIFT); \
        } \
 } while (0)
 #else
-#define zend_set_str_gc_flags(str) GC_FLAGS(str) = IS_STR_INTERNED | IS_STR_PERMANENT
+#define zend_set_str_gc_flags(str) do {\
+       GC_TYPE_INFO(str) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << GC_FLAGS_SHIFT); \
+} while (0)
 #endif
 
 #define zend_accel_store_string(str) do { \
@@ -301,7 +303,7 @@ static void zend_persist_zval(zval *z)
                                        /* make immutable array */
                                        Z_TYPE_FLAGS_P(z) = 0;
                                        GC_SET_REFCOUNT(Z_COUNTED_P(z), 2);
-                                       GC_FLAGS(Z_COUNTED_P(z)) |= IS_ARRAY_IMMUTABLE;
+                                       GC_ADD_FLAGS(Z_COUNTED_P(z), IS_ARRAY_IMMUTABLE);
                                        HT_FLAGS(Z_ARRVAL_P(z)) |= HASH_FLAG_STATIC_KEYS;
                                }
                        }

diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c
index 93df5ae6c29e50e867499587dab7cf507faf941f..ca26b80030f587f89c2a6af856ecbfc74bb3f9eb 100644 (file)
--- a/ext/standard/var_unserializer.c
+++ b/ext/standard/var_unserializer.c
@@ -223,13 +223,13 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
                                        BG(serialize_lock)++;
                                        if (call_user_function_ex(CG(function_table), zv, &wakeup_name, &retval, 0, 0, 1, NULL) == FAILURE || Z_ISUNDEF(retval)) {
                                                wakeup_failed = 1;
-                                               OBJ_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                               GC_ADD_FLAGS(Z_OBJ_P(zv), IS_OBJ_DESTRUCTOR_CALLED);
                                        }
                                        BG(serialize_lock)--;
 
                                        zval_ptr_dtor(&retval);
                                } else {
-                                       OBJ_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                       GC_ADD_FLAGS(Z_OBJ_P(zv), IS_OBJ_DESTRUCTOR_CALLED);
                                }
                        }
 
@@ -603,7 +603,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
        if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
                if (has_wakeup) {
                        ZVAL_DEREF(rval);
-                       OBJ_FLAGS(Z_OBJ_P(rval)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                       GC_ADD_FLAGS(Z_OBJ_P(rval), IS_OBJ_DESTRUCTOR_CALLED);
                }
                return 0;
        }

diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re
index c7a9d2e33bdd550d2f5adb5eb6b2aad11ccce13b..2fba472fbfa0736380827f7cf6a6528b6ea778df 100644 (file)
--- a/ext/standard/var_unserializer.re
+++ b/ext/standard/var_unserializer.re
@@ -221,13 +221,13 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
                                        BG(serialize_lock)++;
                                        if (call_user_function_ex(CG(function_table), zv, &wakeup_name, &retval, 0, 0, 1, NULL) == FAILURE || Z_ISUNDEF(retval)) {
                                                wakeup_failed = 1;
-                                               OBJ_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                               GC_ADD_FLAGS(Z_OBJ_P(zv), IS_OBJ_DESTRUCTOR_CALLED);
                                        }
                                        BG(serialize_lock)--;
 
                                        zval_ptr_dtor(&retval);
                                } else {
-                                       OBJ_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                                       GC_ADD_FLAGS(Z_OBJ_P(zv), IS_OBJ_DESTRUCTOR_CALLED);
                                }
                        }
 
@@ -607,7 +607,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
        if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
                if (has_wakeup) {
                        ZVAL_DEREF(rval);
-                       OBJ_FLAGS(Z_OBJ_P(rval)) |= IS_OBJ_DESTRUCTOR_CALLED;
+                       GC_ADD_FLAGS(Z_OBJ_P(rval), IS_OBJ_DESTRUCTOR_CALLED);
                }
                return 0;
        }