Use zend_always_inline instead of simple inline

Girgias · Girgias · commit 2516abc55187 · 2022-08-01T14:30:51.000+01:00
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
@@ -334,7 +334,6 @@ ZEND_API zend_result zend_get_parameters_array_ex(uint32_t param_count, zval *ar
 /* internal function to efficiently copy parameters when executing __call() */
 ZEND_API zend_result zend_copy_parameters_array(uint32_t param_count, zval *argument_array);
 
-// TODO Replace _ex version with zend_get_parameters_array()
 #define zend_get_parameters_array(ht, param_count, argument_array) \
 	zend_get_parameters_array_ex(param_count, argument_array)
 #define zend_parse_parameters_none() \
@@ -381,7 +380,7 @@ ZEND_API void zend_class_implements(zend_class_entry *class_entry, int num_inter
 
 ZEND_API zend_result zend_register_class_alias_ex(const char *name, size_t name_len, zend_class_entry *ce, bool persistent);
 
-static inline zend_result zend_register_class_alias(const char *name, zend_class_entry *ce) {
+static zend_always_inline zend_result zend_register_class_alias(const char *name, zend_class_entry *ce) {
 	return zend_register_class_alias_ex(name, strlen(name), ce, 1);
 }
 #define zend_register_ns_class_alias(ns, name, ce) \
@@ -540,40 +539,40 @@ ZEND_API void add_assoc_object_ex(zval *arg, const char *key, size_t key_len, ze
 ZEND_API void add_assoc_reference_ex(zval *arg, const char *key, size_t key_len, zend_reference *ref);
 ZEND_API void add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
 
-static inline void add_assoc_long(zval *arg, const char *key, zend_long n) {
+static zend_always_inline void add_assoc_long(zval *arg, const char *key, zend_long n) {
 	add_assoc_long_ex(arg, key, strlen(key), n);
 }
-static inline void add_assoc_null(zval *arg, const char *key) {
+static zend_always_inline void add_assoc_null(zval *arg, const char *key) {
 	add_assoc_null_ex(arg, key, strlen(key));
 }
-static inline void add_assoc_bool(zval *arg, const char *key, bool b) {
+static zend_always_inline void add_assoc_bool(zval *arg, const char *key, bool b) {
 	add_assoc_bool_ex(arg, key, strlen(key), b);
 }
-static inline void add_assoc_resource(zval *arg, const char *key, zend_resource *r) {
+static zend_always_inline void add_assoc_resource(zval *arg, const char *key, zend_resource *r) {
 	add_assoc_resource_ex(arg, key, strlen(key), r);
 }
-static inline void add_assoc_double(zval *arg, const char *key, double d) {
+static zend_always_inline void add_assoc_double(zval *arg, const char *key, double d) {
 	add_assoc_double_ex(arg, key, strlen(key), d);
 }
-static inline void add_assoc_str(zval *arg, const char *key, zend_string *str) {
+static zend_always_inline void add_assoc_str(zval *arg, const char *key, zend_string *str) {
 	add_assoc_str_ex(arg, key, strlen(key), str);
 }
-static inline void add_assoc_string(zval *arg, const char *key, const char *str) {
+static zend_always_inline void add_assoc_string(zval *arg, const char *key, const char *str) {
 	add_assoc_string_ex(arg, key, strlen(key), str);
 }
-static inline void add_assoc_stringl(zval *arg, const char *key, const char *str, size_t length) {
+static zend_always_inline void add_assoc_stringl(zval *arg, const char *key, const char *str, size_t length) {
 	add_assoc_stringl_ex(arg, key, strlen(key), str, length);
 }
-static inline void add_assoc_array(zval *arg, const char *key, zend_array *arr) {
+static zend_always_inline void add_assoc_array(zval *arg, const char *key, zend_array *arr) {
 	add_assoc_array_ex(arg, key, strlen(key), arr);
 }
-static inline void add_assoc_object(zval *arg, const char *key, zend_object *obj) {
+static zend_always_inline void add_assoc_object(zval *arg, const char *key, zend_object *obj) {
 	add_assoc_object_ex(arg, key, strlen(key), obj);
 }
-static inline void add_assoc_reference(zval *arg, const char *key, zend_reference *ref) {
+static zend_always_inline void add_assoc_reference(zval *arg, const char *key, zend_reference *ref) {
 	add_assoc_reference_ex(arg, key, strlen(key), ref);
 }
-static inline void add_assoc_zval(zval *arg, const char *key, zval *value) {
+static zend_always_inline void add_assoc_zval(zval *arg, const char *key, zval *value) {
 	add_assoc_zval_ex(arg, key, strlen(key), value);
 }
 
@@ -626,44 +625,43 @@ ZEND_API void add_property_object_ex(zval *arg, const char *key, size_t key_len,
 ZEND_API void add_property_reference_ex(zval *arg, const char *key, size_t key_len, zend_reference *ref);
 ZEND_API void add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
 
-static inline void add_property_long(zval *arg, const char *key, zend_long n) {
+static zend_always_inline void add_property_long(zval *arg, const char *key, zend_long n) {
 	add_property_long_ex(arg, key, strlen(key), n);
 }
-static inline void add_property_null(zval *arg, const char *key) {
+static zend_always_inline void add_property_null(zval *arg, const char *key) {
 	add_property_null_ex(arg, key, strlen(key));
 }
-static inline void add_property_bool(zval *arg, const char *key, bool b) {
+static zend_always_inline void add_property_bool(zval *arg, const char *key, bool b) {
 	add_property_bool_ex(arg, key, strlen(key), b);
 }
-static inline void add_property_resource(zval *arg, const char *key, zend_resource *r) {
+static zend_always_inline void add_property_resource(zval *arg, const char *key, zend_resource *r) {
 	add_property_resource_ex(arg, key, strlen(key), r);
 }
-static inline void add_property_double(zval *arg, const char *key, double d) {
+static zend_always_inline void add_property_double(zval *arg, const char *key, double d) {
 	add_property_double_ex(arg, key, strlen(key), d);
 }
-static inline void add_property_str(zval *arg, const char *key, zend_string *str) {
+static zend_always_inline void add_property_str(zval *arg, const char *key, zend_string *str) {
 	add_property_str_ex(arg, key, strlen(key), str);
 }
-static inline void add_property_string(zval *arg, const char *key, const char *str) {
+static zend_always_inline void add_property_string(zval *arg, const char *key, const char *str) {
 	add_property_string_ex(arg, key, strlen(key), str);
 }
-static inline void add_property_stringl(zval *arg, const char *key, const char *str, size_t length) {
+static zend_always_inline void add_property_stringl(zval *arg, const char *key, const char *str, size_t length) {
 	add_property_stringl_ex(arg, key, strlen(key), str, length);
 }
-static inline void add_property_array(zval *arg, const char *key, zend_array *arr) {
+static zend_always_inline void add_property_array(zval *arg, const char *key, zend_array *arr) {
 	add_property_array_ex(arg, key, strlen(key), arr);
 }
-static inline void add_property_object(zval *arg, const char *key, zend_object *obj) {
+static zend_always_inline void add_property_object(zval *arg, const char *key, zend_object *obj) {
 	add_property_object_ex(arg, key, strlen(key), obj);
 }
-static inline void add_property_reference(zval *arg, const char *key, zend_reference *ref) {
+static zend_always_inline void add_property_reference(zval *arg, const char *key, zend_reference *ref) {
 	add_property_reference_ex(arg, key, strlen(key), ref);
 }
-static inline void add_property_zval(zval *arg, const char *key, zval *value) {
+static zend_always_inline void add_property_zval(zval *arg, const char *key, zval *value) {
 	add_property_zval_ex(arg, key, strlen(key), value);
 }
 
-// TODO Drop function_table argument?
 ZEND_API zend_result _call_user_function_impl(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], HashTable *named_params);
 
 #define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \
diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
@@ -257,31 +257,31 @@ ZEND_API void  ZEND_FASTCALL zend_hash_internal_pointer_end_ex(HashTable *ht, Ha
 static zend_always_inline zend_result zend_hash_has_more_elements_ex(HashTable *ht, HashPosition *pos) {
 	return (zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS);
 }
-static inline zend_result zend_hash_has_more_elements(HashTable *ht) {
+static zend_always_inline zend_result zend_hash_has_more_elements(HashTable *ht) {
 	return zend_hash_has_more_elements_ex(ht, &ht->nInternalPointer);
 }
-static inline zend_result zend_hash_move_forward(HashTable *ht) {
+static zend_always_inline zend_result zend_hash_move_forward(HashTable *ht) {
 	return zend_hash_move_forward_ex(ht, &ht->nInternalPointer);
 }
-static inline zend_result zend_hash_move_backwards(HashTable *ht) {
+static zend_always_inline zend_result zend_hash_move_backwards(HashTable *ht) {
 	return zend_hash_move_backwards_ex(ht, &ht->nInternalPointer);
 }
-static inline int zend_hash_get_current_key(const HashTable *ht, zend_string **str_index, zend_ulong *num_index) {
+static zend_always_inline int zend_hash_get_current_key(const HashTable *ht, zend_string **str_index, zend_ulong *num_index) {
 	return zend_hash_get_current_key_ex(ht, str_index, num_index, &ht->nInternalPointer);
 }
-static inline void zend_hash_get_current_key_zval(const HashTable *ht, zval *key) {
+static zend_always_inline void zend_hash_get_current_key_zval(const HashTable *ht, zval *key) {
 	zend_hash_get_current_key_zval_ex(ht, key, &ht->nInternalPointer);
 }
-static inline int zend_hash_get_current_key_type(HashTable *ht) {
+static zend_always_inline int zend_hash_get_current_key_type(HashTable *ht) {
 	return zend_hash_get_current_key_type_ex(ht, &ht->nInternalPointer);
 }
-static inline zval* zend_hash_get_current_data(HashTable *ht) {
+static zend_always_inline zval* zend_hash_get_current_data(HashTable *ht) {
 	return zend_hash_get_current_data_ex(ht, &ht->nInternalPointer);
 }
-static inline void zend_hash_internal_pointer_reset(HashTable *ht) {
+static zend_always_inline void zend_hash_internal_pointer_reset(HashTable *ht) {
 	zend_hash_internal_pointer_reset_ex(ht, &ht->nInternalPointer);
 }
-static inline void zend_hash_internal_pointer_end(HashTable *ht) {
+static zend_always_inline void zend_hash_internal_pointer_end(HashTable *ht) {
 	zend_hash_internal_pointer_end_ex(ht, &ht->nInternalPointer);
 }
 
@@ -298,15 +298,15 @@ ZEND_API int   zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t
 ZEND_API void  ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, bucket_compare_func_t compare_func, bool renumber);
 ZEND_API zval* ZEND_FASTCALL zend_hash_minmax(const HashTable *ht, compare_func_t compar, uint32_t flag);
 
-static inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, zend_bool renumber) {
+static zend_always_inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, zend_bool renumber) {
 	zend_hash_sort_ex(ht, zend_sort, compare_func, renumber);
 }
 
-static inline uint32_t zend_hash_num_elements(const HashTable *ht) {
+static zend_always_inline uint32_t zend_hash_num_elements(const HashTable *ht) {
 	return ht->nNumOfElements;
 }
 
-static inline zend_long zend_hash_next_free_element(const HashTable *ht) {
+static zend_always_inline zend_long zend_hash_next_free_element(const HashTable *ht) {
 	return ht->nNextFreeElement;
 }
 
diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h
@@ -27,7 +27,7 @@ BEGIN_EXTERN_C()
 ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface);
 ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *parent_ce, bool checked);
 
-static inline void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce) {
+static zend_always_inline void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce) {
 	zend_do_inheritance_ex(ce, parent_ce, 0);
 }
 
diff --git a/Zend/zend_interfaces.h b/Zend/zend_interfaces.h
@@ -40,19 +40,19 @@ typedef struct _zend_user_iterator {
 
 ZEND_API zval* zend_call_method(zend_object *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval, uint32_t param_count, zval* arg1, zval* arg2);
 
-static inline zval* zend_call_method_with_0_params(zend_object *object, zend_class_entry *obj_ce,
+static zend_always_inline zval* zend_call_method_with_0_params(zend_object *object, zend_class_entry *obj_ce,
 		zend_function **fn_proxy, const char *function_name, zval *retval)
 {
 	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 0, NULL, NULL);
 }
 
-static inline zval* zend_call_method_with_1_params(zend_object *object, zend_class_entry *obj_ce,
+static zend_always_inline zval* zend_call_method_with_1_params(zend_object *object, zend_class_entry *obj_ce,
 		zend_function **fn_proxy, const char *function_name, zval *retval, zval* arg1)
 {
 	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 1, arg1, NULL);
 }
 
-static inline zval* zend_call_method_with_2_params(zend_object *object, zend_class_entry *obj_ce,
+static zend_always_inline zval* zend_call_method_with_2_params(zend_object *object, zend_class_entry *obj_ce,
 		zend_function **fn_proxy, const char *function_name, zval *retval, zval* arg1, zval* arg2)
 {
 	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 2, arg1, arg2);
diff --git a/Zend/zend_llist.h b/Zend/zend_llist.h
@@ -66,22 +66,22 @@ ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos);
 ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos);
 ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos);
 
-static inline void *zend_llist_get_first(zend_llist *l)
+static zend_always_inline void *zend_llist_get_first(zend_llist *l)
 {
 	return zend_llist_get_first_ex(l, NULL);
 }
 
-static inline void *zend_llist_get_last(zend_llist *l)
+static zend_always_inline void *zend_llist_get_last(zend_llist *l)
 {
 	return zend_llist_get_last_ex(l, NULL);
 }
 
-static inline void *zend_llist_get_next(zend_llist *l)
+static zend_always_inline void *zend_llist_get_next(zend_llist *l)
 {
 	return zend_llist_get_next_ex(l, NULL);
 }
 
-static inline void *zend_llist_get_prev(zend_llist *l)
+static zend_always_inline void *zend_llist_get_prev(zend_llist *l)
 {
 	return zend_llist_get_prev_ex(l, NULL);
 }
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
@@ -450,10 +450,10 @@ ZEND_API char*        ZEND_FASTCALL zend_str_toupper_dup_ex(const char *source,
 ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower_ex(zend_string *str, bool persistent);
 ZEND_API zend_string* ZEND_FASTCALL zend_string_toupper_ex(zend_string *str, bool persistent);
 
-static inline zend_string* zend_string_tolower(zend_string *str) {
+static zend_always_inline zend_string* zend_string_tolower(zend_string *str) {
 	return zend_string_tolower_ex(str, false);
 }
-static inline zend_string* zend_string_toupper(zend_string *str) {
+static zend_always_inline zend_string* zend_string_toupper(zend_string *str) {
 	return zend_string_toupper_ex(str, false);
 }
 
diff --git a/Zend/zend_smart_str.h b/Zend/zend_smart_str.h
@@ -60,7 +60,7 @@ static zend_always_inline char* smart_str_extend_ex(smart_str *dest, size_t len,
 	return ret;
 }
 
-static inline char* smart_str_extend(smart_str *dest, size_t length)
+static zend_always_inline char* smart_str_extend(smart_str *dest, size_t length)
 {
 	return smart_str_extend_ex(dest, length, false);
 }
@@ -73,7 +73,7 @@ static zend_always_inline void smart_str_free_ex(smart_str *str, bool persistent
 	str->a = 0;
 }
 
-static inline void smart_str_free(smart_str *str)
+static zend_always_inline void smart_str_free(smart_str *str)
 {
 	smart_str_free_ex(str, false);
 }
@@ -96,7 +96,7 @@ static zend_always_inline void smart_str_trim_to_size_ex(smart_str *str, bool pe
 	}
 }
 
-static inline void smart_str_trim_to_size(smart_str *dest)
+static zend_always_inline void smart_str_trim_to_size(smart_str *dest)
 {
 	smart_str_trim_to_size_ex(dest, false);
 }
@@ -114,7 +114,7 @@ static zend_always_inline zend_string *smart_str_extract_ex(smart_str *str, bool
 	}
 }
 
-static inline zend_string *smart_str_extract(smart_str *dest)
+static zend_always_inline zend_string *smart_str_extract(smart_str *dest)
 {
 	return smart_str_extract_ex(dest, false);
 }
@@ -147,7 +147,7 @@ static zend_always_inline void smart_str_append_long_ex(smart_str *dest, zend_lo
 	smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);
 }
 
-static inline void smart_str_append_long(smart_str *dest, zend_long num)
+static zend_always_inline void smart_str_append_long(smart_str *dest, zend_long num)
 {
 	smart_str_append_long_ex(dest, num, false);
 }
@@ -158,32 +158,32 @@ static zend_always_inline void smart_str_append_unsigned_ex(smart_str *dest, zen
 	smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);
 }
 
-static inline void smart_str_append_unsigned(smart_str *dest, zend_ulong num)
+static zend_always_inline void smart_str_append_unsigned(smart_str *dest, zend_ulong num)
 {
 	smart_str_append_unsigned_ex(dest, num, false);
 }
 
-static inline void smart_str_appendl(smart_str *dest, const char *src, size_t length)
+static zend_always_inline void smart_str_appendl(smart_str *dest, const char *src, size_t length)
 {
 	smart_str_appendl_ex(dest, src, length, false);
 }
-static inline void smart_str_appends_ex(smart_str *dest, const char *src, bool persistent)
+static zend_always_inline void smart_str_appends_ex(smart_str *dest, const char *src, bool persistent)
 {
 	smart_str_appendl_ex(dest, src, strlen(src), persistent);
 }
-static inline void smart_str_appends(smart_str *dest, const char *src)
+static zend_always_inline void smart_str_appends(smart_str *dest, const char *src)
 {
 	smart_str_appendl_ex(dest, src, strlen(src), false);
 }
-static inline void smart_str_append(smart_str *dest, const zend_string *src)
+static zend_always_inline void smart_str_append(smart_str *dest, const zend_string *src)
 {
 	smart_str_append_ex(dest, src, false);
 }
-static inline void smart_str_appendc(smart_str *dest, char ch)
+static zend_always_inline void smart_str_appendc(smart_str *dest, char ch)
 {
 	smart_str_appendc_ex(dest, ch, false);
 }
-static inline void smart_str_append_smart_str(smart_str *dest, const smart_str *src)
+static zend_always_inline void smart_str_append_smart_str(smart_str *dest, const smart_str *src)
 {
 	smart_str_append_smart_str_ex(dest, src, false);
 }
@@ -193,7 +193,7 @@ static zend_always_inline void smart_str_setl(smart_str *dest, const char *src,
 	smart_str_appendl(dest, src, len);
 }
 
-static inline void smart_str_sets(smart_str *dest, const char *src)
+static zend_always_inline void smart_str_sets(smart_str *dest, const char *src)
 {
 	smart_str_setl(dest, src, strlen(src));
 }

Original file line number	Diff line number	Diff line change
`@@ -334,7 +334,6 @@ ZEND_API zend_result zend_get_parameters_array_ex(uint32_t param_count, zval *ar`
`334`	`334`	`/* internal function to efficiently copy parameters when executing __call() */`
`335`	`335`	`ZEND_API zend_result zend_copy_parameters_array(uint32_t param_count, zval *argument_array);`
`336`	`336`
`337`		`-// TODO Replace _ex version with zend_get_parameters_array()`
`338`	`337`	`#define zend_get_parameters_array(ht, param_count, argument_array) \`
`339`	`338`	`zend_get_parameters_array_ex(param_count, argument_array)`
`340`	`339`	`#define zend_parse_parameters_none() \`
`@@ -381,7 +380,7 @@ ZEND_API void zend_class_implements(zend_class_entry *class_entry, int num_inter`
`381`	`380`
`382`	`381`	`ZEND_API zend_result zend_register_class_alias_ex(const char name, size_t name_len, zend_class_entry ce, bool persistent);`
`383`	`382`
`384`		`-static inline zend_result zend_register_class_alias(const char name, zend_class_entry ce) {`
	`383`	`+static zend_always_inline zend_result zend_register_class_alias(const char name, zend_class_entry ce) {`
`385`	`384`	`return zend_register_class_alias_ex(name, strlen(name), ce, 1);`
`386`	`385`	`}`
`387`	`386`	`#define zend_register_ns_class_alias(ns, name, ce) \`
`@@ -540,40 +539,40 @@ ZEND_API void add_assoc_object_ex(zval arg, const char key, size_t key_len, ze`
`540`	`539`	`ZEND_API void add_assoc_reference_ex(zval arg, const char key, size_t key_len, zend_reference *ref);`
`541`	`540`	`ZEND_API void add_assoc_zval_ex(zval arg, const char key, size_t key_len, zval *value);`
`542`	`541`
`543`		`-static inline void add_assoc_long(zval arg, const char key, zend_long n) {`
	`542`	`+static zend_always_inline void add_assoc_long(zval arg, const char key, zend_long n) {`
`544`	`543`	`add_assoc_long_ex(arg, key, strlen(key), n);`
`545`	`544`	`}`
`546`		`-static inline void add_assoc_null(zval arg, const char key) {`
	`545`	`+static zend_always_inline void add_assoc_null(zval arg, const char key) {`
`547`	`546`	`add_assoc_null_ex(arg, key, strlen(key));`
`548`	`547`	`}`
`549`		`-static inline void add_assoc_bool(zval arg, const char key, bool b) {`
	`548`	`+static zend_always_inline void add_assoc_bool(zval arg, const char key, bool b) {`
`550`	`549`	`add_assoc_bool_ex(arg, key, strlen(key), b);`
`551`	`550`	`}`
`552`		`-static inline void add_assoc_resource(zval arg, const char key, zend_resource *r) {`
	`551`	`+static zend_always_inline void add_assoc_resource(zval arg, const char key, zend_resource *r) {`
`553`	`552`	`add_assoc_resource_ex(arg, key, strlen(key), r);`
`554`	`553`	`}`
`555`		`-static inline void add_assoc_double(zval arg, const char key, double d) {`
	`554`	`+static zend_always_inline void add_assoc_double(zval arg, const char key, double d) {`
`556`	`555`	`add_assoc_double_ex(arg, key, strlen(key), d);`
`557`	`556`	`}`
`558`		`-static inline void add_assoc_str(zval arg, const char key, zend_string *str) {`
	`557`	`+static zend_always_inline void add_assoc_str(zval arg, const char key, zend_string *str) {`
`559`	`558`	`add_assoc_str_ex(arg, key, strlen(key), str);`
`560`	`559`	`}`
`561`		`-static inline void add_assoc_string(zval arg, const char key, const char *str) {`
	`560`	`+static zend_always_inline void add_assoc_string(zval arg, const char key, const char *str) {`
`562`	`561`	`add_assoc_string_ex(arg, key, strlen(key), str);`
`563`	`562`	`}`
`564`		`-static inline void add_assoc_stringl(zval arg, const char key, const char *str, size_t length) {`
	`563`	`+static zend_always_inline void add_assoc_stringl(zval arg, const char key, const char *str, size_t length) {`
`565`	`564`	`add_assoc_stringl_ex(arg, key, strlen(key), str, length);`
`566`	`565`	`}`
`567`		`-static inline void add_assoc_array(zval arg, const char key, zend_array *arr) {`
	`566`	`+static zend_always_inline void add_assoc_array(zval arg, const char key, zend_array *arr) {`
`568`	`567`	`add_assoc_array_ex(arg, key, strlen(key), arr);`
`569`	`568`	`}`
`570`		`-static inline void add_assoc_object(zval arg, const char key, zend_object *obj) {`
	`569`	`+static zend_always_inline void add_assoc_object(zval arg, const char key, zend_object *obj) {`
`571`	`570`	`add_assoc_object_ex(arg, key, strlen(key), obj);`
`572`	`571`	`}`
`573`		`-static inline void add_assoc_reference(zval arg, const char key, zend_reference *ref) {`
	`572`	`+static zend_always_inline void add_assoc_reference(zval arg, const char key, zend_reference *ref) {`
`574`	`573`	`add_assoc_reference_ex(arg, key, strlen(key), ref);`
`575`	`574`	`}`
`576`		`-static inline void add_assoc_zval(zval arg, const char key, zval *value) {`
	`575`	`+static zend_always_inline void add_assoc_zval(zval arg, const char key, zval *value) {`
`577`	`576`	`add_assoc_zval_ex(arg, key, strlen(key), value);`
`578`	`577`	`}`
`579`	`578`
`@@ -626,44 +625,43 @@ ZEND_API void add_property_object_ex(zval arg, const char key, size_t key_len,`
`626`	`625`	`ZEND_API void add_property_reference_ex(zval arg, const char key, size_t key_len, zend_reference *ref);`
`627`	`626`	`ZEND_API void add_property_zval_ex(zval arg, const char key, size_t key_len, zval *value);`
`628`	`627`
`629`		`-static inline void add_property_long(zval arg, const char key, zend_long n) {`
	`628`	`+static zend_always_inline void add_property_long(zval arg, const char key, zend_long n) {`
`630`	`629`	`add_property_long_ex(arg, key, strlen(key), n);`
`631`	`630`	`}`
`632`		`-static inline void add_property_null(zval arg, const char key) {`
	`631`	`+static zend_always_inline void add_property_null(zval arg, const char key) {`
`633`	`632`	`add_property_null_ex(arg, key, strlen(key));`
`634`	`633`	`}`
`635`		`-static inline void add_property_bool(zval arg, const char key, bool b) {`
	`634`	`+static zend_always_inline void add_property_bool(zval arg, const char key, bool b) {`
`636`	`635`	`add_property_bool_ex(arg, key, strlen(key), b);`
`637`	`636`	`}`
`638`		`-static inline void add_property_resource(zval arg, const char key, zend_resource *r) {`
	`637`	`+static zend_always_inline void add_property_resource(zval arg, const char key, zend_resource *r) {`
`639`	`638`	`add_property_resource_ex(arg, key, strlen(key), r);`
`640`	`639`	`}`
`641`		`-static inline void add_property_double(zval arg, const char key, double d) {`
	`640`	`+static zend_always_inline void add_property_double(zval arg, const char key, double d) {`
`642`	`641`	`add_property_double_ex(arg, key, strlen(key), d);`
`643`	`642`	`}`
`644`		`-static inline void add_property_str(zval arg, const char key, zend_string *str) {`
	`643`	`+static zend_always_inline void add_property_str(zval arg, const char key, zend_string *str) {`
`645`	`644`	`add_property_str_ex(arg, key, strlen(key), str);`
`646`	`645`	`}`
`647`		`-static inline void add_property_string(zval arg, const char key, const char *str) {`
	`646`	`+static zend_always_inline void add_property_string(zval arg, const char key, const char *str) {`
`648`	`647`	`add_property_string_ex(arg, key, strlen(key), str);`
`649`	`648`	`}`
`650`		`-static inline void add_property_stringl(zval arg, const char key, const char *str, size_t length) {`
	`649`	`+static zend_always_inline void add_property_stringl(zval arg, const char key, const char *str, size_t length) {`
`651`	`650`	`add_property_stringl_ex(arg, key, strlen(key), str, length);`
`652`	`651`	`}`
`653`		`-static inline void add_property_array(zval arg, const char key, zend_array *arr) {`
	`652`	`+static zend_always_inline void add_property_array(zval arg, const char key, zend_array *arr) {`
`654`	`653`	`add_property_array_ex(arg, key, strlen(key), arr);`
`655`	`654`	`}`
`656`		`-static inline void add_property_object(zval arg, const char key, zend_object *obj) {`
	`655`	`+static zend_always_inline void add_property_object(zval arg, const char key, zend_object *obj) {`
`657`	`656`	`add_property_object_ex(arg, key, strlen(key), obj);`
`658`	`657`	`}`
`659`		`-static inline void add_property_reference(zval arg, const char key, zend_reference *ref) {`
	`658`	`+static zend_always_inline void add_property_reference(zval arg, const char key, zend_reference *ref) {`
`660`	`659`	`add_property_reference_ex(arg, key, strlen(key), ref);`
`661`	`660`	`}`
`662`		`-static inline void add_property_zval(zval arg, const char key, zval *value) {`
	`661`	`+static zend_always_inline void add_property_zval(zval arg, const char key, zval *value) {`
`663`	`662`	`add_property_zval_ex(arg, key, strlen(key), value);`
`664`	`663`	`}`
`665`	`664`
`666`		`-// TODO Drop function_table argument?`
`667`	`665`	`ZEND_API zend_result _call_user_function_impl(zval object, zval function_name, zval retval_ptr, uint32_t param_count, zval params[], HashTable named_params);`
`668`	`666`
`669`	`667`	`#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \`
Original file line number	Diff line number	Diff line change
`@@ -257,31 +257,31 @@ ZEND_API void ZEND_FASTCALL zend_hash_internal_pointer_end_ex(HashTable *ht, Ha`
`257`	`257`	`static zend_always_inline zend_result zend_hash_has_more_elements_ex(HashTable ht, HashPosition pos) {`
`258`	`258`	`return (zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS);`
`259`	`259`	`}`
`260`		`-static inline zend_result zend_hash_has_more_elements(HashTable *ht) {`
	`260`	`+static zend_always_inline zend_result zend_hash_has_more_elements(HashTable *ht) {`
`261`	`261`	`return zend_hash_has_more_elements_ex(ht, &ht->nInternalPointer);`
`262`	`262`	`}`
`263`		`-static inline zend_result zend_hash_move_forward(HashTable *ht) {`
	`263`	`+static zend_always_inline zend_result zend_hash_move_forward(HashTable *ht) {`
`264`	`264`	`return zend_hash_move_forward_ex(ht, &ht->nInternalPointer);`
`265`	`265`	`}`
`266`		`-static inline zend_result zend_hash_move_backwards(HashTable *ht) {`
	`266`	`+static zend_always_inline zend_result zend_hash_move_backwards(HashTable *ht) {`
`267`	`267`	`return zend_hash_move_backwards_ex(ht, &ht->nInternalPointer);`
`268`	`268`	`}`
`269`		`-static inline int zend_hash_get_current_key(const HashTable ht, zend_string str_index, zend_ulong num_index) {`
	`269`	`+static zend_always_inline int zend_hash_get_current_key(const HashTable ht, zend_string str_index, zend_ulong num_index) {`
`270`	`270`	`return zend_hash_get_current_key_ex(ht, str_index, num_index, &ht->nInternalPointer);`
`271`	`271`	`}`
`272`		`-static inline void zend_hash_get_current_key_zval(const HashTable ht, zval key) {`
	`272`	`+static zend_always_inline void zend_hash_get_current_key_zval(const HashTable ht, zval key) {`
`273`	`273`	`zend_hash_get_current_key_zval_ex(ht, key, &ht->nInternalPointer);`
`274`	`274`	`}`
`275`		`-static inline int zend_hash_get_current_key_type(HashTable *ht) {`
	`275`	`+static zend_always_inline int zend_hash_get_current_key_type(HashTable *ht) {`
`276`	`276`	`return zend_hash_get_current_key_type_ex(ht, &ht->nInternalPointer);`
`277`	`277`	`}`
`278`		`-static inline zval* zend_hash_get_current_data(HashTable *ht) {`
	`278`	`+static zend_always_inline zval* zend_hash_get_current_data(HashTable *ht) {`
`279`	`279`	`return zend_hash_get_current_data_ex(ht, &ht->nInternalPointer);`
`280`	`280`	`}`
`281`		`-static inline void zend_hash_internal_pointer_reset(HashTable *ht) {`
	`281`	`+static zend_always_inline void zend_hash_internal_pointer_reset(HashTable *ht) {`
`282`	`282`	`zend_hash_internal_pointer_reset_ex(ht, &ht->nInternalPointer);`
`283`	`283`	`}`
`284`		`-static inline void zend_hash_internal_pointer_end(HashTable *ht) {`
	`284`	`+static zend_always_inline void zend_hash_internal_pointer_end(HashTable *ht) {`
`285`	`285`	`zend_hash_internal_pointer_end_ex(ht, &ht->nInternalPointer);`
`286`	`286`	`}`
`287`	`287`
`@@ -298,15 +298,15 @@ ZEND_API int zend_hash_compare(HashTable ht1, HashTable ht2, compare_func_t`
`298`	`298`	`ZEND_API void ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, bucket_compare_func_t compare_func, bool renumber);`
`299`	`299`	`ZEND_API zval* ZEND_FASTCALL zend_hash_minmax(const HashTable *ht, compare_func_t compar, uint32_t flag);`
`300`	`300`
`301`		`-static inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, zend_bool renumber) {`
	`301`	`+static zend_always_inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, zend_bool renumber) {`
`302`	`302`	`zend_hash_sort_ex(ht, zend_sort, compare_func, renumber);`
`303`	`303`	`}`
`304`	`304`
`305`		`-static inline uint32_t zend_hash_num_elements(const HashTable *ht) {`
	`305`	`+static zend_always_inline uint32_t zend_hash_num_elements(const HashTable *ht) {`
`306`	`306`	`return ht->nNumOfElements;`
`307`	`307`	`}`
`308`	`308`
`309`		`-static inline zend_long zend_hash_next_free_element(const HashTable *ht) {`
	`309`	`+static zend_always_inline zend_long zend_hash_next_free_element(const HashTable *ht) {`
`310`	`310`	`return ht->nNextFreeElement;`
`311`	`311`	`}`
`312`	`312`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ BEGIN_EXTERN_C()`
`27`	`27`	`ZEND_API void zend_do_implement_interface(zend_class_entry ce, zend_class_entry iface);`
`28`	`28`	`ZEND_API void zend_do_inheritance_ex(zend_class_entry ce, zend_class_entry parent_ce, bool checked);`
`29`	`29`
`30`		`-static inline void zend_do_inheritance(zend_class_entry ce, zend_class_entry parent_ce) {`
	`30`	`+static zend_always_inline void zend_do_inheritance(zend_class_entry ce, zend_class_entry parent_ce) {`
`31`	`31`	`zend_do_inheritance_ex(ce, parent_ce, 0);`
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -40,19 +40,19 @@ typedef struct _zend_user_iterator {`
`40`	`40`
`41`	`41`	`ZEND_API zval* zend_call_method(zend_object object, zend_class_entry obj_ce, zend_function *fn_proxy, const char function_name, size_t function_name_len, zval retval, uint32_t param_count, zval arg1, zval* arg2);`
`42`	`42`
`43`		`-static inline zval* zend_call_method_with_0_params(zend_object object, zend_class_entry obj_ce,`
	`43`	`+static zend_always_inline zval* zend_call_method_with_0_params(zend_object object, zend_class_entry obj_ce,`
`44`	`44`	`zend_function *fn_proxy, const char function_name, zval *retval)`
`45`	`45`	`{`
`46`	`46`	`return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 0, NULL, NULL);`
`47`	`47`	`}`
`48`	`48`
`49`		`-static inline zval* zend_call_method_with_1_params(zend_object object, zend_class_entry obj_ce,`
	`49`	`+static zend_always_inline zval* zend_call_method_with_1_params(zend_object object, zend_class_entry obj_ce,`
`50`	`50`	`zend_function *fn_proxy, const char function_name, zval retval, zval arg1)`
`51`	`51`	`{`
`52`	`52`	`return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 1, arg1, NULL);`
`53`	`53`	`}`
`54`	`54`
`55`		`-static inline zval* zend_call_method_with_2_params(zend_object object, zend_class_entry obj_ce,`
	`55`	`+static zend_always_inline zval* zend_call_method_with_2_params(zend_object object, zend_class_entry obj_ce,`
`56`	`56`	`zend_function *fn_proxy, const char function_name, zval retval, zval arg1, zval* arg2)`
`57`	`57`	`{`
`58`	`58`	`return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 2, arg1, arg2);`
Original file line number	Diff line number	Diff line change
`@@ -66,22 +66,22 @@ ZEND_API void zend_llist_get_last_ex(zend_llist l, zend_llist_position *pos);`
`66`	`66`	`ZEND_API void zend_llist_get_next_ex(zend_llist l, zend_llist_position *pos);`
`67`	`67`	`ZEND_API void zend_llist_get_prev_ex(zend_llist l, zend_llist_position *pos);`
`68`	`68`
`69`		`-static inline void zend_llist_get_first(zend_llist l)`
	`69`	`+static zend_always_inline void zend_llist_get_first(zend_llist l)`
`70`	`70`	`{`
`71`	`71`	`return zend_llist_get_first_ex(l, NULL);`
`72`	`72`	`}`
`73`	`73`
`74`		`-static inline void zend_llist_get_last(zend_llist l)`
	`74`	`+static zend_always_inline void zend_llist_get_last(zend_llist l)`
`75`	`75`	`{`
`76`	`76`	`return zend_llist_get_last_ex(l, NULL);`
`77`	`77`	`}`
`78`	`78`
`79`		`-static inline void zend_llist_get_next(zend_llist l)`
	`79`	`+static zend_always_inline void zend_llist_get_next(zend_llist l)`
`80`	`80`	`{`
`81`	`81`	`return zend_llist_get_next_ex(l, NULL);`
`82`	`82`	`}`
`83`	`83`
`84`		`-static inline void zend_llist_get_prev(zend_llist l)`
	`84`	`+static zend_always_inline void zend_llist_get_prev(zend_llist l)`
`85`	`85`	`{`
`86`	`86`	`return zend_llist_get_prev_ex(l, NULL);`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -450,10 +450,10 @@ ZEND_API char* ZEND_FASTCALL zend_str_toupper_dup_ex(const char *source,`
`450`	`450`	`ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower_ex(zend_string *str, bool persistent);`
`451`	`451`	`ZEND_API zend_string* ZEND_FASTCALL zend_string_toupper_ex(zend_string *str, bool persistent);`
`452`	`452`
`453`		`-static inline zend_string* zend_string_tolower(zend_string *str) {`
	`453`	`+static zend_always_inline zend_string* zend_string_tolower(zend_string *str) {`
`454`	`454`	`return zend_string_tolower_ex(str, false);`
`455`	`455`	`}`
`456`		`-static inline zend_string* zend_string_toupper(zend_string *str) {`
	`456`	`+static zend_always_inline zend_string* zend_string_toupper(zend_string *str) {`
`457`	`457`	`return zend_string_toupper_ex(str, false);`
`458`	`458`	`}`
`459`	`459`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ static zend_always_inline char* smart_str_extend_ex(smart_str *dest, size_t len,`
`60`	`60`	`return ret;`
`61`	`61`	`}`
`62`	`62`
`63`		`-static inline char* smart_str_extend(smart_str *dest, size_t length)`
	`63`	`+static zend_always_inline char* smart_str_extend(smart_str *dest, size_t length)`
`64`	`64`	`{`
`65`	`65`	`return smart_str_extend_ex(dest, length, false);`
`66`	`66`	`}`
`@@ -73,7 +73,7 @@ static zend_always_inline void smart_str_free_ex(smart_str *str, bool persistent`
`73`	`73`	`str->a = 0;`
`74`	`74`	`}`
`75`	`75`
`76`		`-static inline void smart_str_free(smart_str *str)`
	`76`	`+static zend_always_inline void smart_str_free(smart_str *str)`
`77`	`77`	`{`
`78`	`78`	`smart_str_free_ex(str, false);`
`79`	`79`	`}`
`@@ -96,7 +96,7 @@ static zend_always_inline void smart_str_trim_to_size_ex(smart_str *str, bool pe`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`		`-static inline void smart_str_trim_to_size(smart_str *dest)`
	`99`	`+static zend_always_inline void smart_str_trim_to_size(smart_str *dest)`
`100`	`100`	`{`
`101`	`101`	`smart_str_trim_to_size_ex(dest, false);`
`102`	`102`	`}`
`@@ -114,7 +114,7 @@ static zend_always_inline zend_string smart_str_extract_ex(smart_str str, bool`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`-static inline zend_string smart_str_extract(smart_str dest)`
	`117`	`+static zend_always_inline zend_string smart_str_extract(smart_str dest)`
`118`	`118`	`{`
`119`	`119`	`return smart_str_extract_ex(dest, false);`
`120`	`120`	`}`
`@@ -147,7 +147,7 @@ static zend_always_inline void smart_str_append_long_ex(smart_str *dest, zend_lo`
`147`	`147`	`smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);`
`148`	`148`	`}`
`149`	`149`
`150`		`-static inline void smart_str_append_long(smart_str *dest, zend_long num)`
	`150`	`+static zend_always_inline void smart_str_append_long(smart_str *dest, zend_long num)`
`151`	`151`	`{`
`152`	`152`	`smart_str_append_long_ex(dest, num, false);`
`153`	`153`	`}`
`@@ -158,32 +158,32 @@ static zend_always_inline void smart_str_append_unsigned_ex(smart_str *dest, zen`
`158`	`158`	`smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent);`
`159`	`159`	`}`
`160`	`160`
`161`		`-static inline void smart_str_append_unsigned(smart_str *dest, zend_ulong num)`
	`161`	`+static zend_always_inline void smart_str_append_unsigned(smart_str *dest, zend_ulong num)`
`162`	`162`	`{`
`163`	`163`	`smart_str_append_unsigned_ex(dest, num, false);`
`164`	`164`	`}`
`165`	`165`
`166`		`-static inline void smart_str_appendl(smart_str dest, const char src, size_t length)`
	`166`	`+static zend_always_inline void smart_str_appendl(smart_str dest, const char src, size_t length)`
`167`	`167`	`{`
`168`	`168`	`smart_str_appendl_ex(dest, src, length, false);`
`169`	`169`	`}`
`170`		`-static inline void smart_str_appends_ex(smart_str dest, const char src, bool persistent)`
	`170`	`+static zend_always_inline void smart_str_appends_ex(smart_str dest, const char src, bool persistent)`
`171`	`171`	`{`
`172`	`172`	`smart_str_appendl_ex(dest, src, strlen(src), persistent);`
`173`	`173`	`}`
`174`		`-static inline void smart_str_appends(smart_str dest, const char src)`
	`174`	`+static zend_always_inline void smart_str_appends(smart_str dest, const char src)`
`175`	`175`	`{`
`176`	`176`	`smart_str_appendl_ex(dest, src, strlen(src), false);`
`177`	`177`	`}`
`178`		`-static inline void smart_str_append(smart_str dest, const zend_string src)`
	`178`	`+static zend_always_inline void smart_str_append(smart_str dest, const zend_string src)`
`179`	`179`	`{`
`180`	`180`	`smart_str_append_ex(dest, src, false);`
`181`	`181`	`}`
`182`		`-static inline void smart_str_appendc(smart_str *dest, char ch)`
	`182`	`+static zend_always_inline void smart_str_appendc(smart_str *dest, char ch)`
`183`	`183`	`{`
`184`	`184`	`smart_str_appendc_ex(dest, ch, false);`
`185`	`185`	`}`
`186`		`-static inline void smart_str_append_smart_str(smart_str dest, const smart_str src)`
	`186`	`+static zend_always_inline void smart_str_append_smart_str(smart_str dest, const smart_str src)`
`187`	`187`	`{`
`188`	`188`	`smart_str_append_smart_str_ex(dest, src, false);`
`189`	`189`	`}`
`@@ -193,7 +193,7 @@ static zend_always_inline void smart_str_setl(smart_str dest, const char src,`
`193`	`193`	`smart_str_appendl(dest, src, len);`
`194`	`194`	`}`
`195`	`195`
`196`		`-static inline void smart_str_sets(smart_str dest, const char src)`
	`196`	`+static zend_always_inline void smart_str_sets(smart_str dest, const char src)`
`197`	`197`	`{`
`198`	`198`	`smart_str_setl(dest, src, strlen(src));`
`199`	`199`	`}`