Adjust static inline functions which don't inline

These are found by adding `-Winline` on gcc. The flag is accepted on
clang for compatibility with gcc, but it doesn't do anything.

Mostly, this removes `inline` from the declarations. For local static
functions, there is no point in adding `inline`. This stems from
either a misunderstanding of what it means, or alternatively is a
holdover from ancient times where it may have meant something. A
compiler is free to inline a static function, and specifying inline
doesn't make the compiler inline the function. It does however make
it harder to due analysis of failed inlining, so I remove them.

However, for select functions, this changes them `zend_always_inline`
instead. This is because these functions didn't inline, but probably
should for performance reasons. For instance, `_class_exists_impl` is
used in multiple frameless function handlers. I think in these cases,
the authors were _hoping_ they'd be inlined due to fact that are
important for performance. There's also `_php_search_array`, which is
used with constant args on a variety of functions. It fails to inline
due its size, but if it _did_ inline, it would cut large amounts of
code out, so forcing the inlining seemed worth it.

Author: morrisonlevi

Zend/zend_ast.c

@@ -29,17 +29,17 @@
 
 ZEND_API zend_ast_process_t zend_ast_process = NULL;
 
-static inline void *zend_ast_alloc(size_t size) {
+static void *zend_ast_alloc(size_t size) {
 	return zend_arena_alloc(&CG(ast_arena), size);
 }
 
-static inline void *zend_ast_realloc(void *old, size_t old_size, size_t new_size) {
+static void *zend_ast_realloc(void *old, size_t old_size, size_t new_size) {
 	void *new = zend_ast_alloc(new_size);
 	memcpy(new, old, old_size);
 	return new;
 }
 
-static inline size_t zend_ast_list_size(uint32_t children) {
+static size_t zend_ast_list_size(uint32_t children) {
 	return sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * children;
 }
 
@@ -494,7 +494,7 @@ zend_ast *zend_ast_create_concat_op(zend_ast *op0, zend_ast *op1) {
 	return zend_ast_create_binary_op(ZEND_CONCAT, op0, op1);
 }
 
-static inline bool is_power_of_two(uint32_t n) {
+static zend_always_inline bool is_power_of_two(uint32_t n) {
 	return ((n != 0) && (n == (n & (~n + 1))));
 }
 

Zend/zend_builtin_functions.c

@@ -1053,7 +1053,7 @@ flf_clean:;
 	Z_FLF_PARAM_FREE_STR(2, property_tmp)
 }
 
-static inline void _class_exists_impl(zval *return_value, zend_string *name, bool autoload, int flags, int skip_flags) /* {{{ */
+static zend_always_inline void _class_exists_impl(zval *return_value, zend_string *name, bool autoload, int flags, int skip_flags) /* {{{ */
 {
 	zend_string *lcname;
 	zend_class_entry *ce;
@@ -1088,7 +1088,7 @@ static inline void _class_exists_impl(zval *return_value, zend_string *name, boo
 }
 /* {{{ */
 
-static inline void class_exists_impl(INTERNAL_FUNCTION_PARAMETERS, int flags, int skip_flags) /* {{{ */
+static void class_exists_impl(INTERNAL_FUNCTION_PARAMETERS, int flags, int skip_flags) /* {{{ */
 {
 	zend_string *name;
 	bool autoload = true;
@@ -1386,7 +1386,7 @@ ZEND_FUNCTION(get_exception_handler)
 	}
 }
 
-static inline void get_declared_class_impl(INTERNAL_FUNCTION_PARAMETERS, int flags) /* {{{ */
+static void get_declared_class_impl(INTERNAL_FUNCTION_PARAMETERS, int flags) /* {{{ */
 {
 	zend_string *key;
 	zval *zv;

Zend/zend_exceptions.c

@@ -81,15 +81,9 @@ static int zend_implement_throwable(zend_class_entry *interface, zend_class_entr
 }
 /* }}} */
 
-static inline zend_class_entry *i_get_exception_base(zend_object *object) /* {{{ */
-{
-	return instanceof_function(object->ce, zend_ce_exception) ? zend_ce_exception : zend_ce_error;
-}
-/* }}} */
-
 ZEND_API zend_class_entry *zend_get_exception_base(zend_object *object) /* {{{ */
 {
-	return i_get_exception_base(object);
+	return instanceof_function(object->ce, zend_ce_exception) ? zend_ce_exception : zend_ce_error;
 }
 /* }}} */
 
@@ -115,17 +109,17 @@ void zend_exception_set_previous(zend_object *exception, zend_object *add_previo
 	ZVAL_OBJ(&zv, exception);
 	ex = &zv;
 	do {
-		ancestor = zend_read_property_ex(i_get_exception_base(add_previous), add_previous, ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
+		ancestor = zend_read_property_ex(zend_get_exception_base(add_previous), add_previous, ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
 		ZVAL_DEREF(ancestor);
 		while (Z_TYPE_P(ancestor) == IS_OBJECT) {
 			if (Z_OBJ_P(ancestor) == Z_OBJ_P(ex)) {
 				OBJ_RELEASE(add_previous);
 				return;
 			}
-			ancestor = zend_read_property_ex(i_get_exception_base(Z_OBJ_P(ancestor)), Z_OBJ_P(ancestor), ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
+			ancestor = zend_read_property_ex(zend_get_exception_base(Z_OBJ_P(ancestor)), Z_OBJ_P(ancestor), ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
 			ZVAL_DEREF(ancestor);
 		}
-		base_ce = i_get_exception_base(Z_OBJ_P(ex));
+		base_ce = zend_get_exception_base(Z_OBJ_P(ex));
 		previous = zend_read_property_ex(base_ce, Z_OBJ_P(ex), ZSTR_KNOWN(ZEND_STR_PREVIOUS), 1, &rv);
 		ZVAL_DEREF(previous);
 		if (Z_TYPE_P(previous) == IS_NULL) {
@@ -273,7 +267,7 @@ static zend_object *zend_default_exception_new(zend_class_entry *class_type) /*
 	}
 	Z_SET_REFCOUNT(trace, 0);
 
-	base_ce = i_get_exception_base(object);
+	base_ce = zend_get_exception_base(object);
 
 	if (EXPECTED((class_type != zend_ce_parse_error && class_type != zend_ce_compile_error)
 			|| !(filename = zend_get_compiled_filename()))) {
@@ -311,7 +305,7 @@ ZEND_METHOD(Exception, __construct)
 	zend_class_entry *base_ce;
 
 	object = ZEND_THIS;
-	base_ce = i_get_exception_base(Z_OBJ_P(object));
+	base_ce = zend_get_exception_base(Z_OBJ_P(object));
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|SlO!", &message, &code, &previous, zend_ce_throwable) == FAILURE) {
 		RETURN_THROWS();
@@ -335,9 +329,9 @@ ZEND_METHOD(Exception, __construct)
 
 /* {{{ Exception unserialize checks */
 #define CHECK_EXC_TYPE(id, type) \
-	pvalue = zend_read_property_ex(i_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 1, &value); \
+	pvalue = zend_read_property_ex(zend_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 1, &value); \
 	if (Z_TYPE_P(pvalue) != IS_NULL && Z_TYPE_P(pvalue) != type) { \
-		zend_unset_property(i_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_VAL(ZSTR_KNOWN(id)), ZSTR_LEN(ZSTR_KNOWN(id))); \
+		zend_unset_property(zend_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_VAL(ZSTR_KNOWN(id)), ZSTR_LEN(ZSTR_KNOWN(id))); \
 	}
 
 ZEND_METHOD(Exception, __wakeup)
@@ -401,9 +395,9 @@ ZEND_METHOD(ErrorException, __construct)
 /* }}} */
 
 #define GET_PROPERTY(object, id) \
-	zend_read_property_ex(i_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 0, &rv)
+	zend_read_property_ex(zend_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 0, &rv)
 #define GET_PROPERTY_SILENT(object, id) \
-	zend_read_property_ex(i_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 1, &rv)
+	zend_read_property_ex(zend_get_exception_base(Z_OBJ_P(object)), Z_OBJ_P(object), ZSTR_KNOWN(id), 1, &rv)
 
 /* {{{ Get the file in which the exception occurred */
 ZEND_METHOD(Exception, getFile)
@@ -621,7 +615,7 @@ ZEND_METHOD(Exception, getTraceAsString)
 	ZEND_PARSE_PARAMETERS_NONE();
 
 	zval *object = ZEND_THIS;
-	zend_class_entry *base_ce = i_get_exception_base(Z_OBJ_P(object));
+	zend_class_entry *base_ce = zend_get_exception_base(Z_OBJ_P(object));
 	zval rv;
 	const zval *trace = zend_read_property_ex(base_ce, Z_OBJ_P(object), ZSTR_KNOWN(ZEND_STR_TRACE), 1, &rv);
 	if (EG(exception)) {
@@ -725,7 +719,7 @@ ZEND_METHOD(Exception, __toString)
 
 	exception = ZEND_THIS;
 	/* Reset apply counts */
-	while (Z_TYPE_P(exception) == IS_OBJECT && (base_ce = i_get_exception_base(Z_OBJ_P(exception))) && instanceof_function(Z_OBJCE_P(exception), base_ce)) {
+	while (Z_TYPE_P(exception) == IS_OBJECT && (base_ce = zend_get_exception_base(Z_OBJ_P(exception))) && instanceof_function(Z_OBJCE_P(exception), base_ce)) {
 		if (Z_IS_RECURSIVE_P(exception)) {
 			Z_UNPROTECT_RECURSION_P(exception);
 		} else {
@@ -736,7 +730,7 @@ ZEND_METHOD(Exception, __toString)
 	}
 
 	exception = ZEND_THIS;
-	base_ce = i_get_exception_base(Z_OBJ_P(exception));
+	base_ce = zend_get_exception_base(Z_OBJ_P(exception));
 
 	/* We store the result in the private property string so we can access
 	 * the result in uncaught exception handlers without memleaks. */
@@ -928,7 +922,7 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit
 			if (Z_TYPE(tmp) != IS_STRING) {
 				zend_error(E_WARNING, "%s::__toString() must return a string", ZSTR_VAL(ce_exception->name));
 			} else {
-				zend_update_property_ex(i_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_STRING), &tmp);
+				zend_update_property_ex(zend_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_STRING), &tmp);
 			}
 		}
 		zval_ptr_dtor(&tmp);

Zend/zend_generators.c

@@ -213,7 +213,7 @@ static zend_always_inline void clear_link_to_root(zend_generator *generator) {
 }
 
 /* Check if the node 'generator' is running in a fiber */
-static inline bool check_node_running_in_fiber(zend_generator *generator) {
+static bool check_node_running_in_fiber(zend_generator *generator) {
 	ZEND_ASSERT(generator->execute_data);
 
 	if (EXPECTED(generator->flags & ZEND_GENERATOR_IN_FIBER)) {
@@ -872,7 +872,7 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */
 }
 /* }}} */
 
-static inline void zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */
+static void zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */
 {
 	if (UNEXPECTED(Z_TYPE(generator->value) == IS_UNDEF) && EXPECTED(generator->execute_data) && EXPECTED(generator->node.parent == NULL)) {
 		zend_generator_resume(generator);
@@ -881,7 +881,7 @@ static inline void zend_generator_ensure_initialized(zend_generator *generator)
 }
 /* }}} */
 
-static inline void zend_generator_rewind(zend_generator *generator) /* {{{ */
+static void zend_generator_rewind(zend_generator *generator) /* {{{ */
 {
 	zend_generator_ensure_initialized(generator);
 

ext/hash/hash_gost.c

@@ -203,7 +203,7 @@
 		AA(v, l, r); \
 	}
 
-static inline void Gost(PHP_GOST_CTX *context, uint32_t data[8])
+static void Gost(PHP_GOST_CTX *context, uint32_t data[8])
 {
 	int i;
 	uint32_t l, r, t, key[8], u[8], v[8], w[8], s[8], *h = context->state, *m = data;

ext/hash/hash_snefru.c

@@ -37,7 +37,7 @@ void ph(uint32_t h[16])
 }
 #endif
 
-static inline void Snefru(uint32_t input[16])
+static void Snefru(uint32_t input[16])
 {
 	static const int shifts[4] = {16, 8, 16, 24};
 	int b, index, rshift, lshift;

ext/hash/hash_tiger.c

@@ -132,7 +132,7 @@
 }
 /* }}} */
 
-static inline void TigerFinalize(PHP_TIGER_CTX *context)
+static void TigerFinalize(PHP_TIGER_CTX *context)
 {
 	context->passed += (uint64_t) context->length << 3;
 

ext/json/json_encoder.c

@@ -90,7 +90,7 @@ bool php_json_is_valid_double(double d) /* {{{ */
 }
 /* }}} */
 
-static inline void php_json_encode_double(smart_str *buf, double d, int options) /* {{{ */
+static void php_json_encode_double(smart_str *buf, double d, int options) /* {{{ */
 {
 	size_t len;
 	char num[ZEND_DOUBLE_MAX_LENGTH];

ext/opcache/ZendAccelerator.c

@@ -230,7 +230,7 @@ static ZEND_FUNCTION(accel_chdir)
 	ZCG(cwd_check) = true;
 }
 
-static inline zend_string* accel_getcwd(void)
+static zend_string* accel_getcwd(void)
 {
 	if (ZCG(cwd)) {
 		return ZCG(cwd);

ext/random/engine_mt19937.c

@@ -100,7 +100,7 @@ ZEND_STATIC_ASSERT(
 #define twist(m,u,v)  (m ^ (mixBits(u,v) >> 1) ^ ((uint32_t)(-(int32_t)(loBit(v))) & 0x9908b0dfU))
 #define twist_php(m,u,v)  (m ^ (mixBits(u,v) >> 1) ^ ((uint32_t)(-(int32_t)(loBit(u))) & 0x9908b0dfU))
 
-static inline void mt19937_reload(php_random_status_state_mt19937 *state)
+static void mt19937_reload(php_random_status_state_mt19937 *state)
 {
 	uint32_t *p = state->state;