Try to fix initialization problems

nikic · nikic · commit a29ae1760199 · 2019-09-24T14:33:44.000+02:00
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -2062,7 +2062,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 			}
 			if (ZEND_TYPE_IS_SET(info->type)) {
 				if (ZEND_TYPE_IS_CLASS(info->type)) {
-					const char *type_name = info->type.literal_name;
+					const char *type_name = ZEND_TYPE_LITERAL_NAME(info->type);
 					if (!scope && (!strcasecmp(type_name, "self") || !strcasecmp(type_name, "parent"))) {
 						zend_error_noreturn(E_CORE_ERROR, "Cannot declare a return type of %s outside of a class scope", type_name);
 					}
@@ -2143,9 +2143,9 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 			reg_function->common.arg_info = new_arg_info + 1;
 			for (i = 0; i < num_args; i++) {
 				if (ZEND_TYPE_IS_CLASS(new_arg_info[i].type)) {
-					const char *class_name = new_arg_info[i].type.literal_name;
-					ZEND_TYPE_NAME(new_arg_info[i].type) =
-						zend_string_init_interned(class_name, strlen(class_name), 1);
+					const char *class_name = ZEND_TYPE_LITERAL_NAME(new_arg_info[i].type);
+					ZEND_TYPE_SET_PTR(new_arg_info[i].type,
+						zend_string_init_interned(class_name, strlen(class_name), 1));
 				}
 			}
 		}
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
@@ -120,14 +120,13 @@ typedef void (*copy_ctor_func_t)(zval *pElement);
  * ZEND_TYPE_ENCODE_*() should be used for construction.
  */
 
-/* We could use the extra 32-bit of padding on 64-bit systems. */
 typedef struct {
-	union {
-		zend_class_entry *ce;
-		zend_string *name;
-		const char *literal_name;
-	};
+	/* Not using a union here, because there's no good way to initialize them
+	 * in a way that is supported in both C and C++ (designated initializers
+	 * are only supported since C++20). */
+	void *ptr;
 	uint32_t type_mask;
+	/* TODO: We could use the extra 32-bit of padding on 64-bit systems. */
 } zend_type;
 
 #define _ZEND_TYPE_MASK ((1u<<(IS_VOID+1))-1)
@@ -152,13 +151,19 @@ typedef struct {
 	(((t.type_mask) & _ZEND_TYPE_NAME_BIT) != 0)
 
 #define ZEND_TYPE_IS_ONLY_MASK(t) \
-	((t).type_mask != 0 && (t).ce == NULL)
+	((t).type_mask != 0 && (t).ptr == NULL)
 
 #define ZEND_TYPE_NAME(t) \
-	((t).name)
+	((zend_string *) (t).ptr)
+
+#define ZEND_TYPE_LITERAL_NAME(t) \
+	((const char *) (t).ptr)
 
 #define ZEND_TYPE_CE(t) \
-	((t).ce)
+	((zend_class_entry *) (t).ptr)
+
+#define ZEND_TYPE_SET_PTR(t, _ptr) \
+	((t).ptr = (_ptr))
 
 #define ZEND_TYPE_MASK(t) \
 	((t).type_mask)
@@ -173,32 +178,23 @@ typedef struct {
 	(((t).type_mask & _ZEND_TYPE_NULLABLE_BIT) != 0)
 
 #define ZEND_TYPE_INIT_NONE() \
-	{ .type_mask = 0 }
+	{ NULL, 0 }
 
 #define ZEND_TYPE_INIT_MASK(_type_mask) \
-	{ .type_mask = (_type_mask) }
+	{ NULL, (_type_mask) }
 
 #define ZEND_TYPE_INIT_CODE(code, allow_null) \
 	ZEND_TYPE_INIT_MASK(((code) == _IS_BOOL ? (MAY_BE_FALSE|MAY_BE_TRUE) : (1 << (code))) \
 		| ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0))
 
 #define ZEND_TYPE_INIT_CE(_ce, allow_null) \
-	{ \
-	 	.ce = (_ce), \
-		.type_mask = _ZEND_TYPE_CE_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) \
-	}
+	{ (void *) (_ce), _ZEND_TYPE_CE_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) }
 
 #define ZEND_TYPE_INIT_CLASS(class_name, allow_null) \
-	{ \
-	 	.name = (class_name), \
-		.type_mask = _ZEND_TYPE_NAME_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) \
-	}
+	{ (void *) (class_name), _ZEND_TYPE_NAME_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) }
 
 #define ZEND_TYPE_INIT_CLASS_CONST(class_name, allow_null) \
-	{ \
-		.literal_name = (class_name), \
-		.type_mask = _ZEND_TYPE_NAME_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) \
-	}
+	{ (void *) (class_name), _ZEND_TYPE_NAME_BIT | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) }
 
 typedef union _zend_value {
 	zend_long         lval;				/* long value */
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
@@ -602,8 +602,8 @@ static void accel_copy_permanent_strings(zend_new_interned_string_func_t new_int
 			}
 			for (i = 0 ; i < num_args; i++) {
 				if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
-					ZEND_TYPE_NAME(arg_info[i].type) =
-						new_interned_string(ZEND_TYPE_NAME(arg_info[i].type));
+					ZEND_TYPE_SET_PTR(arg_info[i].type,
+						new_interned_string(ZEND_TYPE_NAME(arg_info[i].type)));
 				}
 			}
 		}
diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
@@ -237,7 +237,7 @@ static void zend_hash_clone_prop_info(HashTable *ht)
 				zend_class_entry *ce = ZEND_TYPE_CE(prop_info->type);
 				if (IN_ARENA(ce)) {
 					ce = ARENA_REALLOC(ce);
-					ZEND_TYPE_CE(prop_info->type) = ce;
+					ZEND_TYPE_SET_PTR(prop_info->type, ce);
 				}
 			}
 		}
diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
@@ -501,7 +501,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array            *op_arra
 				if (ZEND_TYPE_IS_CLASS(p->type)) {
 					zend_string *type_name = ZEND_TYPE_NAME(p->type);
 					SERIALIZE_STR(type_name);
-					ZEND_TYPE_NAME(p->type) = type_name;
+					ZEND_TYPE_SET_PTR(p->type, type_name);
 				}
 				p++;
 			}
@@ -575,11 +575,11 @@ static void zend_file_cache_serialize_prop_info(zval                     *zv,
 		if (ZEND_TYPE_IS_NAME(prop->type)) {
 			zend_string *name = ZEND_TYPE_NAME(prop->type);
 			SERIALIZE_STR(name);
-			ZEND_TYPE_NAME(prop->type) = name;
+			ZEND_TYPE_SET_PTR(prop->type, name);
 		} else if (ZEND_TYPE_IS_CE(prop->type)) {
 			zend_class_entry *ce = ZEND_TYPE_CE(prop->type);
 			SERIALIZE_PTR(ce);
-			ZEND_TYPE_CE(prop->type) = ce;
+			ZEND_TYPE_SET_PTR(prop->type, ce);
 		}
 	}
 }
@@ -1198,7 +1198,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
 				if (ZEND_TYPE_IS_CLASS(p->type)) {
 					zend_string *type_name = ZEND_TYPE_NAME(p->type);
 					UNSERIALIZE_STR(type_name);
-					ZEND_TYPE_NAME(p->type) = type_name;
+					ZEND_TYPE_SET_PTR(p->type, type_name);
 				}
 				p++;
 			}
@@ -1272,11 +1272,11 @@ static void zend_file_cache_unserialize_prop_info(zval                    *zv,
 		if (ZEND_TYPE_IS_NAME(prop->type)) {
 			zend_string *name = ZEND_TYPE_NAME(prop->type);
 			UNSERIALIZE_STR(name);
-			ZEND_TYPE_NAME(prop->type) = name;
+			ZEND_TYPE_SET_PTR(prop->type, name);
 		} else if (ZEND_TYPE_IS_CE(prop->type)) {
 			zend_class_entry *ce = ZEND_TYPE_CE(prop->type);
 			UNSERIALIZE_PTR(ce);
-			ZEND_TYPE_CE(prop->type) = ce;
+			ZEND_TYPE_SET_PTR(prop->type, ce);
 		}
 	}
 }
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
@@ -502,7 +502,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 			if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
 				zend_string *type_name = ZEND_TYPE_NAME(arg_info[i].type);
 				zend_accel_store_interned_string(type_name);
-				ZEND_TYPE_NAME(arg_info[i].type) = type_name;
+				ZEND_TYPE_SET_PTR(arg_info[i].type, type_name);
 			}
 		}
 		if (op_array->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
@@ -662,7 +662,7 @@ static void zend_persist_property_info(zval *zv)
 	if (ZEND_TYPE_IS_NAME(prop->type)) {
 		zend_string *class_name = ZEND_TYPE_NAME(prop->type);
 		zend_accel_store_interned_string(class_name);
-		ZEND_TYPE_NAME(prop->type) = class_name;
+		ZEND_TYPE_SET_PTR(prop->type, class_name);
 	}
 }
 
@@ -942,7 +942,7 @@ static void zend_update_parent_ce(zend_class_entry *ce)
 				if (ce->type == ZEND_USER_CLASS) {
 					ce = zend_shared_alloc_get_xlat_entry(ce);
 					if (ce) {
-						ZEND_TYPE_CE(prop->type) = ce;
+						ZEND_TYPE_SET_PTR(prop->type, ce);
 					}
 				}
 			}
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
@@ -225,7 +225,7 @@ static void zend_persist_op_array_calc_ex(zend_op_array *op_array)
 			if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
 				zend_string *type_name = ZEND_TYPE_NAME(arg_info[i].type);
 				ADD_INTERNED_STRING(type_name);
-				ZEND_TYPE_NAME(arg_info[i].type) = type_name;
+				ZEND_TYPE_SET_PTR(arg_info[i].type, type_name);
 			}
 		}
 	}
@@ -305,7 +305,7 @@ static void zend_persist_property_info_calc(zval *zv)
 		if (ZEND_TYPE_IS_NAME(prop->type)) {
 			zend_string *class_name = ZEND_TYPE_NAME(prop->type);
 			ADD_INTERNED_STRING(class_name);
-			ZEND_TYPE_NAME(prop->type) = class_name;
+			ZEND_TYPE_SET_PTR(prop->type, class_name);
 		}
 		if (ZCG(accel_directives).save_comments && prop->doc_comment) {
 			ADD_STRING(prop->doc_comment);

Original file line number	Diff line number	Diff line change
`@@ -2062,7 +2062,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio`
`2062`	`2062`	`}`
`2063`	`2063`	`if (ZEND_TYPE_IS_SET(info->type)) {`
`2064`	`2064`	`if (ZEND_TYPE_IS_CLASS(info->type)) {`
`2065`		`- const char *type_name = info->type.literal_name;`
	`2065`	`+ const char *type_name = ZEND_TYPE_LITERAL_NAME(info->type);`
`2066`	`2066`	`if (!scope && (!strcasecmp(type_name, "self") \|\| !strcasecmp(type_name, "parent"))) {`
`2067`	`2067`	`zend_error_noreturn(E_CORE_ERROR, "Cannot declare a return type of %s outside of a class scope", type_name);`
`2068`	`2068`	`}`
`@@ -2143,9 +2143,9 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio`
`2143`	`2143`	`reg_function->common.arg_info = new_arg_info + 1;`
`2144`	`2144`	`for (i = 0; i < num_args; i++) {`
`2145`	`2145`	`if (ZEND_TYPE_IS_CLASS(new_arg_info[i].type)) {`
`2146`		`- const char *class_name = new_arg_info[i].type.literal_name;`
`2147`		`- ZEND_TYPE_NAME(new_arg_info[i].type) =`
`2148`		`- zend_string_init_interned(class_name, strlen(class_name), 1);`
	`2146`	`+ const char *class_name = ZEND_TYPE_LITERAL_NAME(new_arg_info[i].type);`
	`2147`	`+ ZEND_TYPE_SET_PTR(new_arg_info[i].type,`
	`2148`	`+ zend_string_init_interned(class_name, strlen(class_name), 1));`
`2149`	`2149`	`}`
`2150`	`2150`	`}`
`2151`	`2151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -602,8 +602,8 @@ static void accel_copy_permanent_strings(zend_new_interned_string_func_t new_int`
`602`	`602`	`}`
`603`	`603`	`for (i = 0 ; i < num_args; i++) {`
`604`	`604`	`if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {`
`605`		`- ZEND_TYPE_NAME(arg_info[i].type) =`
`606`		`- new_interned_string(ZEND_TYPE_NAME(arg_info[i].type));`
	`605`	`+ ZEND_TYPE_SET_PTR(arg_info[i].type,`
	`606`	`+ new_interned_string(ZEND_TYPE_NAME(arg_info[i].type)));`
`607`	`607`	`}`
`608`	`608`	`}`
`609`	`609`	`}`
Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ static void zend_hash_clone_prop_info(HashTable *ht)`
`237`	`237`	`zend_class_entry *ce = ZEND_TYPE_CE(prop_info->type);`
`238`	`238`	`if (IN_ARENA(ce)) {`
`239`	`239`	`ce = ARENA_REALLOC(ce);`
`240`		`- ZEND_TYPE_CE(prop_info->type) = ce;`
	`240`	`+ ZEND_TYPE_SET_PTR(prop_info->type, ce);`
`241`	`241`	`}`
`242`	`242`	`}`
`243`	`243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -501,7 +501,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra`
`501`	`501`	`if (ZEND_TYPE_IS_CLASS(p->type)) {`
`502`	`502`	`zend_string *type_name = ZEND_TYPE_NAME(p->type);`
`503`	`503`	`SERIALIZE_STR(type_name);`
`504`		`- ZEND_TYPE_NAME(p->type) = type_name;`
	`504`	`+ ZEND_TYPE_SET_PTR(p->type, type_name);`
`505`	`505`	`}`
`506`	`506`	`p++;`
`507`	`507`	`}`
`@@ -575,11 +575,11 @@ static void zend_file_cache_serialize_prop_info(zval *zv,`
`575`	`575`	`if (ZEND_TYPE_IS_NAME(prop->type)) {`
`576`	`576`	`zend_string *name = ZEND_TYPE_NAME(prop->type);`
`577`	`577`	`SERIALIZE_STR(name);`
`578`		`- ZEND_TYPE_NAME(prop->type) = name;`
	`578`	`+ ZEND_TYPE_SET_PTR(prop->type, name);`
`579`	`579`	`} else if (ZEND_TYPE_IS_CE(prop->type)) {`
`580`	`580`	`zend_class_entry *ce = ZEND_TYPE_CE(prop->type);`
`581`	`581`	`SERIALIZE_PTR(ce);`
`582`		`- ZEND_TYPE_CE(prop->type) = ce;`
	`582`	`+ ZEND_TYPE_SET_PTR(prop->type, ce);`
`583`	`583`	`}`
`584`	`584`	`}`
`585`	`585`	`}`
`@@ -1198,7 +1198,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr`
`1198`	`1198`	`if (ZEND_TYPE_IS_CLASS(p->type)) {`
`1199`	`1199`	`zend_string *type_name = ZEND_TYPE_NAME(p->type);`
`1200`	`1200`	`UNSERIALIZE_STR(type_name);`
`1201`		`- ZEND_TYPE_NAME(p->type) = type_name;`
	`1201`	`+ ZEND_TYPE_SET_PTR(p->type, type_name);`
`1202`	`1202`	`}`
`1203`	`1203`	`p++;`
`1204`	`1204`	`}`
`@@ -1272,11 +1272,11 @@ static void zend_file_cache_unserialize_prop_info(zval *zv,`
`1272`	`1272`	`if (ZEND_TYPE_IS_NAME(prop->type)) {`
`1273`	`1273`	`zend_string *name = ZEND_TYPE_NAME(prop->type);`
`1274`	`1274`	`UNSERIALIZE_STR(name);`
`1275`		`- ZEND_TYPE_NAME(prop->type) = name;`
	`1275`	`+ ZEND_TYPE_SET_PTR(prop->type, name);`
`1276`	`1276`	`} else if (ZEND_TYPE_IS_CE(prop->type)) {`
`1277`	`1277`	`zend_class_entry *ce = ZEND_TYPE_CE(prop->type);`
`1278`	`1278`	`UNSERIALIZE_PTR(ce);`
`1279`		`- ZEND_TYPE_CE(prop->type) = ce;`
	`1279`	`+ ZEND_TYPE_SET_PTR(prop->type, ce);`
`1280`	`1280`	`}`
`1281`	`1281`	`}`
`1282`	`1282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -502,7 +502,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc`
`502`	`502`	`if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {`
`503`	`503`	`zend_string *type_name = ZEND_TYPE_NAME(arg_info[i].type);`
`504`	`504`	`zend_accel_store_interned_string(type_name);`
`505`		`- ZEND_TYPE_NAME(arg_info[i].type) = type_name;`
	`505`	`+ ZEND_TYPE_SET_PTR(arg_info[i].type, type_name);`
`506`	`506`	`}`
`507`	`507`	`}`
`508`	`508`	`if (op_array->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {`
`@@ -662,7 +662,7 @@ static void zend_persist_property_info(zval *zv)`
`662`	`662`	`if (ZEND_TYPE_IS_NAME(prop->type)) {`
`663`	`663`	`zend_string *class_name = ZEND_TYPE_NAME(prop->type);`
`664`	`664`	`zend_accel_store_interned_string(class_name);`
`665`		`- ZEND_TYPE_NAME(prop->type) = class_name;`
	`665`	`+ ZEND_TYPE_SET_PTR(prop->type, class_name);`
`666`	`666`	`}`
`667`	`667`	`}`
`668`	`668`
`@@ -942,7 +942,7 @@ static void zend_update_parent_ce(zend_class_entry *ce)`
`942`	`942`	`if (ce->type == ZEND_USER_CLASS) {`
`943`	`943`	`ce = zend_shared_alloc_get_xlat_entry(ce);`
`944`	`944`	`if (ce) {`
`945`		`- ZEND_TYPE_CE(prop->type) = ce;`
	`945`	`+ ZEND_TYPE_SET_PTR(prop->type, ce);`
`946`	`946`	`}`
`947`	`947`	`}`
`948`	`948`	`}`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ static void zend_persist_op_array_calc_ex(zend_op_array *op_array)`
`225`	`225`	`if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {`
`226`	`226`	`zend_string *type_name = ZEND_TYPE_NAME(arg_info[i].type);`
`227`	`227`	`ADD_INTERNED_STRING(type_name);`
`228`		`- ZEND_TYPE_NAME(arg_info[i].type) = type_name;`
	`228`	`+ ZEND_TYPE_SET_PTR(arg_info[i].type, type_name);`
`229`	`229`	`}`
`230`	`230`	`}`
`231`	`231`	`}`
`@@ -305,7 +305,7 @@ static void zend_persist_property_info_calc(zval *zv)`
`305`	`305`	`if (ZEND_TYPE_IS_NAME(prop->type)) {`
`306`	`306`	`zend_string *class_name = ZEND_TYPE_NAME(prop->type);`
`307`	`307`	`ADD_INTERNED_STRING(class_name);`
`308`		`- ZEND_TYPE_NAME(prop->type) = class_name;`
	`308`	`+ ZEND_TYPE_SET_PTR(prop->type, class_name);`
`309`	`309`	`}`
`310`	`310`	`if (ZCG(accel_directives).save_comments && prop->doc_comment) {`
`311`	`311`	`ADD_STRING(prop->doc_comment);`