https://github.com/php/php-src/pull/10597

Author: simpletoimplement

src/php7/hash_ptr.h

@@ -5,7 +5,7 @@
   | Author: Oleg Grenrus <[email protected]>                     |
   | See CREDITS for contributors                                         |
   | This defines hash_si_ptr.                                            |
-  | It is like hash_si, but the key is always a non-zero zend_uintptr_t  |
+  | It is like hash_si, but the key is always a non-zero uintptr_t  |
   +----------------------------------------------------------------------+
 */
 
@@ -31,12 +31,12 @@
  * @see hash_si_ptr
  */
 struct hash_si_ptr_pair {
-	zend_uintptr_t key; /**< The key: The address of a pointer, casted to an int (won't be dereferenced). */
+	uintptr_t key; /**< The key: The address of a pointer, casted to an int (won't be dereferenced). */
 	uint32_t value;		/**< Value. */
 };
 
 /** Hash-array.
- * Like c++ std::unordered_map<zend_uintptr_t, int32_t>, but does not allow HASH_PTR_KEY_INVALID as a key.
+ * Like c++ std::unordered_map<uintptr_t, int32_t>, but does not allow HASH_PTR_KEY_INVALID as a key.
  * Current implementation uses linear probing.
  * @author Oleg Grenrus <[email protected]>
  */
@@ -67,7 +67,7 @@ void hash_si_ptr_deinit(struct hash_si_ptr *h);
  * @return 0 on success, 1 or 2 else.
  */
 /*
-int hash_si_ptr_insert (struct hash_si_ptr *h, const zend_uintptr_t key, uint32_t value);
+int hash_si_ptr_insert (struct hash_si_ptr *h, const uintptr_t key, uint32_t value);
 */
 
 /** Finds value from hash_si_ptr.
@@ -79,7 +79,7 @@ int hash_si_ptr_insert (struct hash_si_ptr *h, const zend_uintptr_t key, uint32_
  * @return 0 if found, 1 if not.
  */
 /*
-int hash_si_ptr_find (struct hash_si_ptr *h, const zend_uintptr_t key, uint32_t * value);
+int hash_si_ptr_find (struct hash_si_ptr *h, const uintptr_t key, uint32_t * value);
 */
 
 /** Returns size of hash_si_ptr.
@@ -99,7 +99,7 @@ static zend_always_inline size_t hash_si_ptr_size(struct hash_si_ptr *h) {
  *
  * @return SIZE_MAX or old, unmodified key
  */
-size_t hash_si_ptr_find_or_insert(struct hash_si_ptr *h, const zend_uintptr_t key, uint32_t value);
+size_t hash_si_ptr_find_or_insert(struct hash_si_ptr *h, const uintptr_t key, uint32_t value);
 
 /** Returns capacity of hash_si_ptr.
  * @param h Pointer to hash_si_ptr struct.

src/php7/hash_si_ptr.c

@@ -22,7 +22,7 @@
 #include "igbinary_bswap.h"
 
 /* This assumes that pointers differ in low addresses rather than high addresses */
-inline static uint32_t inline_hash_of_address(zend_uintptr_t ptr) {
+inline static uint32_t inline_hash_of_address(uintptr_t ptr) {
 #if UINTPTR_MAX > UINT32_MAX
 	uint64_t hash = ptr;
 	hash *= 0x5e2d58d8b3bce8d9;
@@ -130,7 +130,7 @@ inline static void hash_si_ptr_rehash(struct hash_si_ptr *h) {
  * @param value - If the key does not exist, this is the value to associate with key
  * @return the old value, or SIZE_MAX if the key is brand new.
  */
-size_t hash_si_ptr_find_or_insert(struct hash_si_ptr *h, const zend_uintptr_t key, uint32_t value) {
+size_t hash_si_ptr_find_or_insert(struct hash_si_ptr *h, const uintptr_t key, uint32_t value) {
 	size_t size;
 	size_t mask;
 	uint32_t hv;

src/php7/igbinary.c

@@ -246,7 +246,7 @@ struct deferred_call {
 #endif
 	} data;
 #if PHP_VERSION_ID >= 70400
-	zend_bool is_unserialize;
+	bool is_unserialize;
 #endif
 };
 /** Unserializer data.
@@ -268,7 +268,7 @@ struct igbinary_unserialize_data {
 	struct deferred_call *deferred; /**< objects&data for calls to __unserialize/__wakeup */
 	size_t deferred_capacity;     /**< capacity of objects in array for calls to __unserialize/__wakeup */
 	uint32_t deferred_count;        /**< count of objects in array for calls to __unserialize/__wakeup. NOTE: Current php releases including 8.1 limit the total number of objects to a 32-bit integer. */
-	zend_bool deferred_finished;    /**< whether the deferred calls were performed */
+	bool deferred_finished;    /**< whether the deferred calls were performed */
 	struct deferred_dtor_tracker deferred_dtor_tracker;  /**< refcounted objects and arrays to call dtor on after unserializing. See i_zval_ptr_dtor */
 #if PHP_VERSION_ID >= 70400
 	HashTable *ref_props; /**< objects&data for calls to __unserialize/__wakeup */
@@ -324,9 +324,9 @@ zend_always_inline static uint64_t igbinary_unserialize64(struct igbinary_unseri
 zend_always_inline static int igbinary_unserialize_long(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zend_long *ret);
 zend_always_inline static int igbinary_unserialize_double(struct igbinary_unserialize_data *igsd, double *ret);
 zend_always_inline static zend_string *igbinary_unserialize_string(struct igbinary_unserialize_data *igsd, enum igbinary_type t);
-zend_always_inline static zend_string *igbinary_unserialize_chararray(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zend_bool check_interned);
+zend_always_inline static zend_string *igbinary_unserialize_chararray(struct igbinary_unserialize_data *igsd, enum igbinary_type t, bool check_interned);
 
-zend_always_inline static int igbinary_unserialize_array(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, int flags, zend_bool create_ref);
+zend_always_inline static int igbinary_unserialize_array(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, int flags, bool create_ref);
 zend_always_inline static int igbinary_unserialize_object(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, int flags);
 static int igbinary_unserialize_object_ser(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, zend_class_entry *ce);
 
@@ -548,7 +548,7 @@ static int igbinary_finish_deferred_calls(struct igbinary_unserialize_data *igsd
 	uint32_t i;
 	struct deferred_call *deferred_arr;
 	uint32_t deferred_count = igsd->deferred_count;
-	zend_bool delayed_call_failed = 0;
+	bool delayed_call_failed = 0;
 	igsd->deferred_finished = 1;
 	if (deferred_count == 0) { /* nothing to do */
 		return 0;
@@ -1494,28 +1494,28 @@ inline static int igbinary_serialize_array(struct igbinary_serialize_data *igsd,
 /* TODO: Use different result codes for missing keys and errors */
 zend_always_inline static int igbinary_serialize_array_ref(struct igbinary_serialize_data *igsd, zval * const z, bool object) {
 	size_t t;
-	zend_uintptr_t key;  /* The address of the pointer to the zend_refcounted struct or other struct */
+	uintptr_t key;  /* The address of the pointer to the zend_refcounted struct or other struct */
 	static int INVALID_KEY;  /* Not used, but we take the pointer of this knowing other zvals won't share it*/
 
 	/* Similar to php_var_serialize_intern's first part, as well as php_add_var_hash, for printing R: (reference) or r:(object) */
 	/* However, it differs from the built in serialize() in that references to objects are preserved when serializing and unserializing? (TODO check, test for backwards compatibility) */
 
 	ZEND_ASSERT(Z_ISREF_P(z) || (object && Z_TYPE_P(z) == IS_OBJECT) || Z_TYPE_P(z) == IS_ARRAY);
-	// zend_bool is_ref = Z_ISREF_P(z);
+	// bool is_ref = Z_ISREF_P(z);
 	/* Do I have to dereference object references so that reference ids will be the same as in php5? */
 	/* If I do, then more tests fail. */
 	/* is_ref || IS_OBJECT implies it has a unique refcounted struct */
 	// NOTE: The original code would always use the same memory address - Z_COUNTED_P is the start of an object/array/reference
 // 	if (object && Z_TYPE_P(z) == IS_OBJECT) {
-// 		key = (zend_uintptr_t)Z_OBJ_P(z); /* expand object handle(uint32_t), cast to 32-bit/64-bit pointer */
+// 		key = (uintptr_t)Z_OBJ_P(z); /* expand object handle(uint32_t), cast to 32-bit/64-bit pointer */
 // 	} else if (is_ref) {
 // 		/* NOTE: PHP switched from `zval*` to `zval` for the values stored in HashTables.
 // 		 * If an array has two references to the same ZVAL, then those references will have different zvals.
 // 		 * We use Z_COUNTED_P(ref), which will be the same if (and only if) the references are the same. */
 // 		/* is_ref implies there is a unique reference counting pointer for the reference */
-// 		key = (zend_uintptr_t)Z_COUNTED_P(z);
+// 		key = (uintptr_t)Z_COUNTED_P(z);
 // 	} else if (EXPECTED(Z_TYPE_P(z) == IS_ARRAY)) {
-// 		key = (zend_uintptr_t)Z_ARR_P(z);
+// 		key = (uintptr_t)Z_ARR_P(z);
 // 	} else {
 // 		/* Nothing else is going to reference this when this is serialized, this isn't ref counted or an object, shouldn't be reached. */
 // 		/* Increment the reference id for the deserializer, give up. */
@@ -1528,9 +1528,9 @@ zend_always_inline static int igbinary_serialize_array_ref(struct igbinary_seria
 	/* because that's the way it was serialized in php5. */
 	/* Does this work with different forms of recursive arrays? */
 	if (igsd->references_id == 0 && !object) {
-		key = (zend_uintptr_t)&INVALID_KEY;
+		key = (uintptr_t)&INVALID_KEY;
 	} else {
-		key = (zend_uintptr_t)z->value.ptr;
+		key = (uintptr_t)z->value.ptr;
 	}
 
 	t = hash_si_ptr_find_or_insert(&igsd->references, key, igsd->references_id);
@@ -2407,7 +2407,7 @@ static ZEND_COLD zend_never_inline zend_string* igbinary_unserialize_extremely_l
 /* }}} */
 /* {{{ igbinary_unserialize_chararray */
 /** Unserializes chararray of string. Returns NULL on error. */
-inline static zend_string *igbinary_unserialize_chararray(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zend_bool check_interned) {
+inline static zend_string *igbinary_unserialize_chararray(struct igbinary_unserialize_data *igsd, enum igbinary_type t, bool check_interned) {
 	size_t l;
 	zend_string *zstr;
 
@@ -2490,7 +2490,7 @@ inline static zend_string *igbinary_unserialize_chararray(struct igbinary_unseri
 /* }}} */
 /* {{{ igbinary_unserialize_array */
 /** Unserializes a PHP array. */
-zend_always_inline static int igbinary_unserialize_array(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, int flags, zend_bool create_ref) {
+zend_always_inline static int igbinary_unserialize_array(struct igbinary_unserialize_data *igsd, enum igbinary_type t, zval *const z, int flags, bool create_ref) {
 	/* WANT_REF means that z will be wrapped by an IS_REFERENCE */
 	uint32_t n;
 	uint32_t i;
@@ -2708,7 +2708,7 @@ inline static int igbinary_unserialize_object_properties(struct igbinary_unseria
 	zval *z_deref;
 
 	HashTable *h;
-	zend_bool did_extend;
+	bool did_extend;
 
 	if (t == igbinary_type_array8) {
 		if (IGB_NEEDS_MORE_DATA(igsd, 1)) {
@@ -2845,7 +2845,7 @@ inline static int igbinary_unserialize_object_properties(struct igbinary_unseria
 					if (igsd->ref_props) {
 						/* Remove old entry from ref_props table, if it exists. */
 						zend_hash_index_del(
-							igsd->ref_props, ((zend_uintptr_t) prototype_value) >> ZEND_MM_ALIGNMENT_LOG2);
+							igsd->ref_props, ((uintptr_t) prototype_value) >> ZEND_MM_ALIGNMENT_LOG2);
 					}
 				}
 #endif
@@ -2927,7 +2927,7 @@ inline static int igbinary_unserialize_object_properties(struct igbinary_unseria
 					zend_hash_init(igsd->ref_props, 8, NULL, NULL, 0);
 				}
 				zend_hash_index_update_ptr(
-					igsd->ref_props, ((zend_uintptr_t) vp) >> ZEND_MM_ALIGNMENT_LOG2, info);
+					igsd->ref_props, ((uintptr_t) vp) >> ZEND_MM_ALIGNMENT_LOG2, info);
 			}
 		}
 #endif
@@ -3459,7 +3459,7 @@ static int igbinary_unserialize_zval(struct igbinary_unserialize_data *igsd, zva
 #if PHP_VERSION_ID >= 70400
 				zend_property_info *info = NULL;
 				if (igsd->ref_props) {
-					info = zend_hash_index_find_ptr(igsd->ref_props, ((zend_uintptr_t) z) >> ZEND_MM_ALIGNMENT_LOG2);
+					info = zend_hash_index_find_ptr(igsd->ref_props, ((uintptr_t) z) >> ZEND_MM_ALIGNMENT_LOG2);
 				}
 #endif
 				ZVAL_NEW_REF(z, z);

src/php7/igbinary_zend_hash.h

@@ -63,14 +63,14 @@ static zend_always_inline zval *igbinary_zend_hash_index_add_or_find(HashTable *
 # define zend_hash_real_init_packed(ht) zend_hash_real_init((ht), 1)
 # define HT_SIZE_TO_MASK(size) (-(size))
 # define HT_FLAGS(ht) ((ht)->u.flags)
-static zend_always_inline zend_bool zend_string_equal_content(zend_string *s1, zend_string *s2)
+static zend_always_inline bool zend_string_equal_content(zend_string *s1, zend_string *s2)
 {
 	return ZSTR_LEN(s1) == ZSTR_LEN(s2) && !memcmp(ZSTR_VAL(s1), ZSTR_VAL(s2), ZSTR_LEN(s1));
 }
 #endif /* PHP_VERSION_ID < 70300 */
 
-/* {{{ igbinary_zend_hash_find_bucket(const HashTable *ht, zend_string *key, zend_bool known_hash) */
-static zend_always_inline Bucket *igbinary_zend_hash_find_bucket(const HashTable *ht, zend_string *key, zend_bool known_hash)
+/* {{{ igbinary_zend_hash_find_bucket(const HashTable *ht, zend_string *key, bool known_hash) */
+static zend_always_inline Bucket *igbinary_zend_hash_find_bucket(const HashTable *ht, zend_string *key, bool known_hash)
 {
 	zend_ulong h;
 	uint32_t nIndex;

src/php7/php_igbinary.h

@@ -25,7 +25,7 @@ extern zend_module_entry igbinary_module_entry;
 #endif
 
 ZEND_BEGIN_MODULE_GLOBALS(igbinary)
-	zend_bool compact_strings;
+	bool compact_strings;
 ZEND_END_MODULE_GLOBALS(igbinary)
 
 #ifdef ZTS