diff -u -p -d -r Zend/zend_alloc.c Zend/zend_alloc.c
--- Zend/zend_alloc.c	2007-10-07 22:31:00.000000000 -0700
+++ Zend/zend_alloc.c	2007-10-07 22:22:00.000000000 -0700
@@ -670,7 +670,7 @@ static void *_zend_mm_alloc_int(zend_mm_
 static void _zend_mm_free_int(zend_mm_heap *heap, void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 static void *_zend_mm_realloc_int(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 
-static inline unsigned int zend_mm_high_bit(size_t _size) /* {{{ */
+static always_inline unsigned int zend_mm_high_bit(size_t _size) /* {{{ */
 {
 #if defined(__GNUC__) && defined(i386)
     unsigned int n;
@@ -692,7 +692,7 @@ static inline unsigned int zend_mm_high_
 }
 /* }}} */
 
-static inline unsigned int zend_mm_low_bit(size_t _size) /* {{{ */
+static always_inline unsigned int zend_mm_low_bit(size_t _size) /* {{{ */
 {
 #if defined(__GNUC__) && defined(i386)
     unsigned int n;
@@ -718,7 +718,7 @@ static inline unsigned int zend_mm_low_b
 }
 /* }}} */
 
-static inline void zend_mm_add_to_rest_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
+static always_inline void zend_mm_add_to_rest_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
 {
 	zend_mm_free_block *prev, *next;
 
@@ -736,7 +736,7 @@ static inline void zend_mm_add_to_rest_l
 }
 /* }}} */
 
-static inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
+static always_inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
 {
 	size_t size;
 	size_t index;
@@ -798,7 +798,7 @@ static inline void zend_mm_add_to_free_l
 }
 /* }}} */
 
-static inline void zend_mm_remove_from_free_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
+static always_inline void zend_mm_remove_from_free_list(zend_mm_heap *heap, zend_mm_free_block *mm_block) /* {{{ */
 {
 	zend_mm_free_block *prev = mm_block->prev_free_block;
 	zend_mm_free_block *next = mm_block->next_free_block;
@@ -870,7 +870,7 @@ subst_block:
 }
 /* }}} */
 
-static inline void zend_mm_init(zend_mm_heap *heap) /* {{{ */
+static always_inline void zend_mm_init(zend_mm_heap *heap) /* {{{ */
 {
 	zend_mm_free_block* p;
 	int i;
@@ -2326,7 +2326,7 @@ ZEND_API size_t _zend_mem_block_size(voi
 
 #if defined(__GNUC__) && defined(i386)
 
-static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) /* {{{ */
+static always_inline size_t safe_address(size_t nmemb, size_t size, size_t offset) /* {{{ */
 {
 	size_t res = nmemb;
 	unsigned long overflow ;
@@ -2347,7 +2347,7 @@ static inline size_t safe_address(size_t
 
 #else
 
-static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) /* {{{ */
+static always_inline size_t safe_address(size_t nmemb, size_t size, size_t offset) /* {{{ */
 {
 	size_t res = nmemb * size + offset;
 	double _d  = (double)nmemb * (double)size + (double)offset;
diff -u -p -d -r Zend/zend_compile.c Zend/zend_compile.c
--- Zend/zend_compile.c	2007-10-06 22:15:02.000000000 -0700
+++ Zend/zend_compile.c	2007-10-07 22:22:00.000000000 -0700
@@ -663,7 +663,7 @@ void zend_do_assign(znode *result, znode
 }
 /* }}} */
 
-static inline zend_bool zend_is_function_or_method_call(znode *variable) /* {{{ */
+static always_inline zend_bool zend_is_function_or_method_call(znode *variable) /* {{{ */
 {
 	zend_uint type = variable->u.EA.type;
 
@@ -705,7 +705,7 @@ void zend_do_assign_ref(znode *result, z
 }
 /* }}} */
 
-static inline void do_begin_loop(TSRMLS_D) /* {{{ */
+static always_inline void do_begin_loop(TSRMLS_D) /* {{{ */
 {
 	zend_brk_cont_element *brk_cont_element;
 	int parent;
@@ -718,7 +718,7 @@ static inline void do_begin_loop(TSRMLS_
 }
 /* }}} */
 
-static inline void do_end_loop(int cont_addr TSRMLS_DC) /* {{{ */
+static always_inline void do_end_loop(int cont_addr TSRMLS_DC) /* {{{ */
 {
 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = cont_addr;
 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
@@ -2562,7 +2562,7 @@ static zend_bool do_inherit_property_acc
 }
 /* }}} */
 
-static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
+static always_inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
 {
 	if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) {
 		zend_error(E_CORE_ERROR, "Class %v could not implement interface %v", ce->name, iface->name);
Only in Zend: zend_config.h
diff -u -p -d -r Zend/zend_execute.c Zend/zend_execute.c
--- Zend/zend_execute.c	2007-10-07 22:31:00.000000000 -0700
+++ Zend/zend_execute.c	2007-10-07 22:22:00.000000000 -0700
@@ -65,7 +65,7 @@ static void zend_extension_fcall_end_han
 
 #define TEMP_VAR_STACK_LIMIT 2000
 
-static inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref) /* {{{ */
+static always_inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref) /* {{{ */
 {
 	int failure = 0;
 
@@ -87,7 +87,7 @@ static inline void zend_pzval_unlock_fun
 }
 /* }}} */
 
-static inline void zend_pzval_unlock_free_func(zval *z) /* {{{ */
+static always_inline void zend_pzval_unlock_free_func(zval *z) /* {{{ */
 {
 	int failure = 0;
 	if (!Z_DELREF_P(z)) {
@@ -179,7 +179,7 @@ ZEND_API zval** zend_get_compiled_variab
 }
 /* }}} */
 
-static inline void zend_get_cv_address(zend_uchar utype, zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC) /* {{{ */
+static always_inline void zend_get_cv_address(zend_uchar utype, zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC) /* {{{ */
 {
 	zval *new_zval = &EG(uninitialized_zval);
 
@@ -188,13 +188,13 @@ static inline void zend_get_cv_address(z
 }
 /* }}} */
 
-static inline zval *_get_zval_ptr_tmp(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
+static always_inline zval *_get_zval_ptr_tmp(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
 {
 	return should_free->var = &T(node->u.var).tmp_var;
 }
 /* }}} */
 
-static inline zval *_get_zval_ptr_var(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
+static always_inline zval *_get_zval_ptr_var(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
 {
 	if (T(node->u.var).var.ptr) {
 		PZVAL_UNLOCK(T(node->u.var).var.ptr, should_free);
@@ -248,7 +248,7 @@ static inline zval *_get_zval_ptr_var(zn
 }
 /* }}} */
 
-static inline zval *_get_zval_ptr_cv(znode *node, temp_variable *Ts, int type TSRMLS_DC) /* {{{ */
+static always_inline zval *_get_zval_ptr_cv(znode *node, temp_variable *Ts, int type TSRMLS_DC) /* {{{ */
 {
 	zval ***ptr = &CV_OF(node->u.var);
 
@@ -278,7 +278,7 @@ static inline zval *_get_zval_ptr_cv(zno
 }
 /* }}} */
 
-static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
+static always_inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
 {
 /*	should_free->is_var = 0; */
 	switch (node->op_type) {
@@ -307,7 +307,7 @@ static inline zval *_get_zval_ptr(znode 
 }
 /* }}} */
 
-static inline zval **_get_zval_ptr_ptr_var(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
+static always_inline zval **_get_zval_ptr_ptr_var(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) /* {{{ */
 {
 	zval** ptr_ptr = T(node->u.var).var.ptr_ptr;
 
@@ -321,7 +321,7 @@ static inline zval **_get_zval_ptr_ptr_v
 }
 /* }}} */
 
-static inline zval **_get_zval_ptr_ptr_cv(znode *node, temp_variable *Ts, int type TSRMLS_DC) /* {{{ */
+static always_inline zval **_get_zval_ptr_ptr_cv(znode *node, temp_variable *Ts, int type TSRMLS_DC) /* {{{ */
 {
 	zval ***ptr = &CV_OF(node->u.var);
 
@@ -351,7 +351,7 @@ static inline zval **_get_zval_ptr_ptr_c
 }
 /* }}} */
 
-static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
+static always_inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
 {
 	if (node->op_type == IS_CV) {
 		should_free->var = 0;
@@ -365,7 +365,7 @@ static inline zval **_get_zval_ptr_ptr(z
 }
 /* }}} */
 
-static inline zval *_get_obj_zval_ptr_unused(TSRMLS_D) /* {{{ */
+static always_inline zval *_get_obj_zval_ptr_unused(TSRMLS_D) /* {{{ */
 {
 	if (EG(This)) {
 		return EG(This);
@@ -376,7 +376,7 @@ static inline zval *_get_obj_zval_ptr_un
 }
 /* }}} */
 
-static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
+static always_inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
 {
 	if (op->op_type == IS_UNUSED) {
 		if (EG(This)) {
@@ -392,7 +392,7 @@ static inline zval **_get_obj_zval_ptr_p
 }
 /* }}} */
 
-static inline zval **_get_obj_zval_ptr_ptr_unused(TSRMLS_D) /* {{{ */
+static always_inline zval **_get_obj_zval_ptr_ptr_unused(TSRMLS_D) /* {{{ */
 {
 	if (EG(This)) {
 		return &EG(This);
@@ -403,7 +403,7 @@ static inline zval **_get_obj_zval_ptr_p
 }
 /* }}} */
 
-static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
+static always_inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) /* {{{ */
 {
 	if (op->op_type == IS_UNUSED) {
 		if (EG(This)) {
@@ -417,7 +417,7 @@ static inline zval *_get_obj_zval_ptr(zn
 }
 /* }}} */
 
-static inline void zend_switch_free(zend_op *opline, temp_variable *Ts TSRMLS_DC) /* {{{ */
+static always_inline void zend_switch_free(zend_op *opline, temp_variable *Ts TSRMLS_DC) /* {{{ */
 {
 	switch (opline->op1.op_type) {
 		case IS_VAR:
@@ -502,7 +502,7 @@ static void zend_assign_to_variable_refe
 /* }}} */
 
 /* this should modify object only if it's empty */
-static inline void make_real_object(zval **object_ptr TSRMLS_DC) /* {{{ */
+static always_inline void make_real_object(zval **object_ptr TSRMLS_DC) /* {{{ */
 {
 	if (Z_TYPE_PP(object_ptr) == IS_NULL
 		|| (Z_TYPE_PP(object_ptr) == IS_BOOL && Z_LVAL_PP(object_ptr) == 0)
@@ -517,7 +517,7 @@ static inline void make_real_object(zval
 }
 /* }}} */
 
-static inline char * zend_verify_arg_class_kind(zend_arg_info *cur_arg_info, ulong fetch_type, zstr *class_name, zend_class_entry **pce TSRMLS_DC) /* {{{ */
+static always_inline char * zend_verify_arg_class_kind(zend_arg_info *cur_arg_info, ulong fetch_type, zstr *class_name, zend_class_entry **pce TSRMLS_DC) /* {{{ */
 {
 	*pce = zend_u_fetch_class(UG(unicode) ? IS_UNICODE : IS_STRING, cur_arg_info->class_name, cur_arg_info->class_name_len, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
 
@@ -530,7 +530,7 @@ static inline char * zend_verify_arg_cla
 }
 /* }}} */
 
-static inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, zend_arg_info *cur_arg_info, char *need_msg, zstr need_kind, char *given_msg, zstr given_kind TSRMLS_DC) /* {{{ */
+static always_inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, zend_arg_info *cur_arg_info, char *need_msg, zstr need_kind, char *given_msg, zstr given_kind TSRMLS_DC) /* {{{ */
 {
 	zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
 	zstr fname = zf->common.function_name;
@@ -554,7 +554,7 @@ static inline int zend_verify_arg_error(
 }
 /* }}} */
 
-static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC) /* {{{ */
+static always_inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC) /* {{{ */
 {
 	zend_arg_info *cur_arg_info;
 	char *need_msg;
@@ -594,7 +594,7 @@ static inline int zend_verify_arg_type(z
 }
 /* }}} */
 
-static inline void zend_assign_to_object(znode *result, zval **object_ptr, znode *op2, znode *value_op, temp_variable *Ts, int opcode TSRMLS_DC) /* {{{ */
+static always_inline void zend_assign_to_object(znode *result, zval **object_ptr, znode *op2, znode *value_op, temp_variable *Ts, int opcode TSRMLS_DC) /* {{{ */
 {
 	zval *object;
 	zend_free_op free_op2, free_value;
@@ -683,7 +683,7 @@ static inline void zend_assign_to_object
 }
 /* }}} */
 
-static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2, zval *value, int type, temp_variable *Ts TSRMLS_DC) /* {{{ */
+static always_inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2, zval *value, int type, temp_variable *Ts TSRMLS_DC) /* {{{ */
 {
 	int failure = 0;
 	zend_free_op free_op1;
@@ -918,7 +918,7 @@ done_setting_var:
 }
 /* }}} */
 
-static inline void zend_receive(zval **variable_ptr_ptr, zval *value TSRMLS_DC) /* {{{ */
+static always_inline void zend_receive(zval **variable_ptr_ptr, zval *value TSRMLS_DC) /* {{{ */
 {
 	int failure = 0;
 
@@ -958,7 +958,7 @@ static void zend_extension_fcall_end_han
 }
 /* }}} */
 
-static inline HashTable *zend_get_target_symbol_table(zend_op *opline, temp_variable *Ts, int type, zval *variable TSRMLS_DC) /* {{{ */
+static always_inline HashTable *zend_get_target_symbol_table(zend_op *opline, temp_variable *Ts, int type, zval *variable TSRMLS_DC) /* {{{ */
 {
 	switch (opline->op2.u.EA.type) {
 		case ZEND_FETCH_LOCAL:
@@ -982,7 +982,7 @@ static inline HashTable *zend_get_target
 }
 /* }}} */
 
-static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, zval *dim, int type TSRMLS_DC) /* {{{ */
+static always_inline zval **zend_fetch_dimension_address_inner(HashTable *ht, zval *dim, int type TSRMLS_DC) /* {{{ */
 {
 	zval **retval;
 	zstr offset_key;
@@ -1379,7 +1379,7 @@ static void zend_fetch_property_address(
 }
 /* }}} */
 
-static inline zend_brk_cont_element* zend_brk_cont(int nest_levels, int array_offset, zend_op_array *op_array, temp_variable *Ts TSRMLS_DC) /* {{{ */
+static always_inline zend_brk_cont_element* zend_brk_cont(int nest_levels, int array_offset, zend_op_array *op_array, temp_variable *Ts TSRMLS_DC) /* {{{ */
 {
 	int original_nest_levels;
 	zend_brk_cont_element *jmp_to;
diff -u -p -d -r Zend/zend_execute.h Zend/zend_execute.h
--- Zend/zend_execute.h	2007-09-11 04:23:12.000000000 -0700
+++ Zend/zend_execute.h	2007-10-07 22:22:01.000000000 -0700
@@ -67,7 +67,7 @@ ZEND_API void execute(zend_op_array *op_
 ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, int return_value_used TSRMLS_DC);
 ZEND_API int zend_is_true(zval *op);
 #define safe_free_zval_ptr(p) safe_free_zval_ptr_rel(p ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
-static inline void safe_free_zval_ptr_rel(zval *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+static always_inline void safe_free_zval_ptr_rel(zval *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	TSRMLS_FETCH();
 
@@ -84,7 +84,7 @@ ZEND_API int zend_eval_string_ex(char *s
 ZEND_API int zend_u_eval_string(zend_uchar type, zstr str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_u_eval_string_ex(zend_uchar type, zstr str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 
-static inline int i_zend_is_true(zval *op)
+static always_inline int i_zend_is_true(zval *op)
 {
 	int result;
 
@@ -153,7 +153,7 @@ ZEND_API int zval_update_constant(zval *
 ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC);
 
 /* dedicated Zend executor functions - do not use! */
-static inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
+static always_inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
 {
 	void **p = EG(argument_stack).top_element-2;
 	int delete_count = (int)(zend_uintptr_t) *p;
@@ -167,7 +167,7 @@ static inline void zend_ptr_stack_clear_
 	EG(argument_stack).top_element = p;
 }
 
-static inline int zend_ptr_stack_get_arg(int requested_arg, void **data TSRMLS_DC)
+static always_inline int zend_ptr_stack_get_arg(int requested_arg, void **data TSRMLS_DC)
 {
 	void **p = EG(argument_stack).top_element-2;
 	int arg_count = (int)(zend_uintptr_t) *p;
Only in Zend: zend_gc.c
Only in Zend: zend_gc.h
diff -u -p -d -r Zend/zend.h Zend/zend.h
--- Zend/zend.h	2007-10-07 22:31:00.000000000 -0700
+++ Zend/zend.h	2007-10-07 22:22:01.000000000 -0700
@@ -269,7 +269,7 @@ typedef union _zstr {
 extern ZEND_API zstr null_zstr;
 extern ZEND_API zstr empty_zstr;
 
-static inline zstr _to_zstr(void *v) {
+static always_inline zstr _to_zstr(void *v) {
 	zstr ret;
 	ret.v = v;
 	return ret;
@@ -751,7 +751,7 @@ END_EXTERN_C()
 	  (!memcmp((ustr).s,(str),(slen))): \
 	  (!zend_cmp_unicode_and_literal((ustr).u, ulen, str, slen)))
 
-static inline int ZEND_U_CASE_EQUAL(zend_uchar type, zstr ustr, int ulen, char *str, int slen)
+static always_inline int ZEND_U_CASE_EQUAL(zend_uchar type, zstr ustr, int ulen, char *str, int slen)
 {
 	zstr lcname;
 	int ret;
diff -u -p -d -r Zend/zend_hash.h Zend/zend_hash.h
--- Zend/zend_hash.h	2007-10-07 22:31:00.000000000 -0700
+++ Zend/zend_hash.h	2007-10-07 22:22:01.000000000 -0700
@@ -313,7 +313,7 @@ ZEND_API int zend_hash_rehash(HashTable 
  *                  -- Ralf S. Engelschall <rse@engelschall.com>
  */
 
-static inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
+static always_inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
 {
 	register ulong hash = 5381;
 
Only in Zend: zend_ini_parser.c
Only in Zend: zend_ini_parser.h
Only in Zend: zend_ini_parser.output
Only in Zend: zend_ini_scanner.c
diff -u -p -d -r Zend/zend_interfaces.h Zend/zend_interfaces.h
--- Zend/zend_interfaces.h	2007-01-01 01:29:21.000000000 -0800
+++ Zend/zend_interfaces.h	2007-10-07 22:22:01.000000000 -0700
@@ -49,7 +49,7 @@ ZEND_API zval* zend_u_call_method(zval *
 #define zend_call_method_with_2_params(obj, obj_ce, fn_proxy, function_name, retval, arg1, arg2) \
 	zend_call_method(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 2, arg1, arg2 TSRMLS_CC)
 
-static inline zval* zend_call_method(zval **obj, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2 TSRMLS_DC)
+static always_inline zval* zend_call_method(zval **obj, zend_class_entry *obj_ce, zend_function **fn_proxy, char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2 TSRMLS_DC)
 {
 	return zend_u_call_method(obj, obj_ce, fn_proxy, IS_STRING, ZSTR(function_name), function_name_len, retval_ptr_ptr, param_count, arg1, arg2 TSRMLS_CC);
 }
Only in Zend: zend_language_parser.c
Only in Zend: zend_language_parser.h
Only in Zend: zend_language_parser.output
Only in Zend: zend_language_scanner.c
diff -u -p -d -r Zend/zend_object_handlers.c Zend/zend_object_handlers.c
--- Zend/zend_object_handlers.c	2007-10-06 22:15:03.000000000 -0700
+++ Zend/zend_object_handlers.c	2007-10-07 22:22:00.000000000 -0700
@@ -175,7 +175,7 @@ static int zend_verify_property_access(z
 }
 /* }}} */
 
-static inline zend_bool is_derived_class(zend_class_entry *child_class, zend_class_entry *parent_class) /* {{{ */
+static always_inline zend_bool is_derived_class(zend_class_entry *child_class, zend_class_entry *parent_class) /* {{{ */
 {
 	child_class = child_class->parent;
 	while (child_class) {
@@ -702,7 +702,7 @@ ZEND_API void zend_std_call_user_call(IN
  * Returns the function address that should be called, or NULL
  * if no such function exists.
  */
-static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, zstr function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
+static always_inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, zstr function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
 {
 	if (!ce) {
 		return 0;
@@ -772,7 +772,7 @@ ZEND_API int zend_check_protected(zend_c
 }
 /* }}} */
 
-static inline zend_class_entry * zend_get_function_root_class(zend_function *fbc) /* {{{ */
+static always_inline zend_class_entry * zend_get_function_root_class(zend_function *fbc) /* {{{ */
 {
 	return fbc->common.prototype ? fbc->common.prototype->common.scope : fbc->common.scope;
 }
diff -u -p -d -r Zend/zend_operators.c Zend/zend_operators.c
--- Zend/zend_operators.c	2007-10-06 22:15:03.000000000 -0700
+++ Zend/zend_operators.c	2007-10-07 22:22:00.000000000 -0700
@@ -1856,7 +1856,7 @@ ZEND_API int numeric_compare_function(zv
 }
 /* }}} */
 
-static inline void zend_free_obj_get_result(zval *op) /* {{{ */
+static always_inline void zend_free_obj_get_result(zval *op) /* {{{ */
 {
 	if (op) {
 		if (Z_REFCOUNT_P(op) == 0) {
diff -u -p -d -r Zend/zend_operators.h Zend/zend_operators.h
--- Zend/zend_operators.h	2007-07-20 17:34:41.000000000 -0700
+++ Zend/zend_operators.h	2007-10-07 22:22:01.000000000 -0700
@@ -78,7 +78,7 @@ ZEND_API unsigned long zend_u_strtoul(co
 ZEND_API double zend_u_strtod(const UChar *nptr, UChar **endptr);
 END_EXTERN_C()
 
-static inline zend_uchar is_numeric_string(char *str, int length, long *lval, double *dval, int allow_errors)
+static always_inline zend_uchar is_numeric_string(char *str, int length, long *lval, double *dval, int allow_errors)
 {
 	long local_lval;
 	double local_dval;
@@ -147,7 +147,7 @@ static inline zend_uchar is_numeric_stri
 	return 0;
 }
 
-static inline zend_uchar is_numeric_unicode(UChar *str, int length, long *lval, double *dval, int allow_errors)
+static always_inline zend_uchar is_numeric_unicode(UChar *str, int length, long *lval, double *dval, int allow_errors)
 {
 	long local_lval;
 	double local_dval;
@@ -219,13 +219,13 @@ static inline zend_uchar is_numeric_unic
 	return 0;
 }
 
-static inline UChar*
+static always_inline UChar*
 zend_u_memnstr(UChar *haystack, UChar *needle, int needle_len, UChar *end)
 {
 	return u_strFindFirst(haystack, end - haystack, needle, needle_len);
 }
 
-static inline char *
+static always_inline char *
 zend_memnstr(char *haystack, char *needle, int needle_len, char *end)
 {
 	char *p = haystack;
@@ -250,7 +250,7 @@ zend_memnstr(char *haystack, char *needl
 	return NULL;
 }
 
-static inline void *zend_memrchr(const void *s, int c, size_t n)
+static always_inline void *zend_memrchr(const void *s, int c, size_t n)
 {
 	register unsigned char *e;
 
diff -u -p -d -r Zend/zend_ptr_stack.h Zend/zend_ptr_stack.h
--- Zend/zend_ptr_stack.h	2007-01-01 01:29:21.000000000 -0800
+++ Zend/zend_ptr_stack.h	2007-10-07 22:22:01.000000000 -0700
@@ -52,7 +52,7 @@ END_EXTERN_C()
 
 /*	Not doing this with a macro because of the loop unrolling in the element assignment.
 	Just using a macro for 3 in the body for readability sake. */
-static inline void zend_ptr_stack_3_push(zend_ptr_stack *stack, void *a, void *b, void *c)
+static always_inline void zend_ptr_stack_3_push(zend_ptr_stack *stack, void *a, void *b, void *c)
 {
 #define ZEND_PTR_STACK_NUM_ARGS 3
 
@@ -66,7 +66,7 @@ static inline void zend_ptr_stack_3_push
 #undef ZEND_PTR_STACK_NUM_ARGS
 }
 
-static inline void zend_ptr_stack_2_push(zend_ptr_stack *stack, void *a, void *b)
+static always_inline void zend_ptr_stack_2_push(zend_ptr_stack *stack, void *a, void *b)
 {
 #define ZEND_PTR_STACK_NUM_ARGS 2
 
@@ -79,7 +79,7 @@ static inline void zend_ptr_stack_2_push
 #undef ZEND_PTR_STACK_NUM_ARGS
 }
 
-static inline void zend_ptr_stack_3_pop(zend_ptr_stack *stack, void **a, void **b, void **c)
+static always_inline void zend_ptr_stack_3_pop(zend_ptr_stack *stack, void **a, void **b, void **c)
 {
 	*a = *(--stack->top_element);
 	*b = *(--stack->top_element);
@@ -87,14 +87,14 @@ static inline void zend_ptr_stack_3_pop(
 	stack->top -= 3;
 }
 
-static inline void zend_ptr_stack_2_pop(zend_ptr_stack *stack, void **a, void **b)
+static always_inline void zend_ptr_stack_2_pop(zend_ptr_stack *stack, void **a, void **b)
 {
 	*a = *(--stack->top_element);
 	*b = *(--stack->top_element);
 	stack->top -= 2;
 }
 
-static inline void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr)
+static always_inline void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr)
 {
 	ZEND_PTR_STACK_RESIZE_IF_NEEDED(stack, 1)
 
@@ -102,7 +102,7 @@ static inline void zend_ptr_stack_push(z
 	*(stack->top_element++) = ptr;
 }
 
-static inline void *zend_ptr_stack_pop(zend_ptr_stack *stack)
+static always_inline void *zend_ptr_stack_pop(zend_ptr_stack *stack)
 {
 	stack->top--;
 	return *(--stack->top_element);
diff -u -p -d -r Zend/zend_unicode.c Zend/zend_unicode.c
--- Zend/zend_unicode.c	2007-07-11 04:19:58.000000000 -0700
+++ Zend/zend_unicode.c	2007-10-07 22:22:00.000000000 -0700
@@ -707,7 +707,7 @@ ZEND_API int zend_is_valid_identifier(UC
 /* }}} */
 
 /* {{{ zend_normalize_string */
-static inline void zend_normalize_string(UChar **dest, int32_t *dest_len, UChar *src, int src_len, UErrorCode *status)
+static always_inline void zend_normalize_string(UChar **dest, int32_t *dest_len, UChar *src, int src_len, UErrorCode *status)
 {
 	UChar *buffer = NULL;
 	int32_t buffer_len;
diff -u -p -d -r Zend/zend_unicode.h Zend/zend_unicode.h
--- Zend/zend_unicode.h	2007-01-11 14:55:33.000000000 -0800
+++ Zend/zend_unicode.h	2007-10-07 22:22:01.000000000 -0700
@@ -98,7 +98,7 @@ ZEND_API void zend_raise_conversion_erro
  * Function to get a codepoint at position n. Iterates over codepoints starting from the
  * beginning of the string. Does not check for n > length, this is left up to the caller.
  */
-static inline UChar32 zend_get_codepoint_at(UChar *str, int length, int n)
+static always_inline UChar32 zend_get_codepoint_at(UChar *str, int length, int n)
 {
 	int32_t offset = 0;
 	UChar32 c = 0;
@@ -115,7 +115,7 @@ static inline UChar32 zend_get_codepoint
  * Convert a single codepoint to UChar sequence (1 or 2).
  * The UChar buffer is assumed to be large enough.
  */
-static inline int zend_codepoint_to_uchar(UChar32 codepoint, UChar *buf)
+static always_inline int zend_codepoint_to_uchar(UChar32 codepoint, UChar *buf)
 {
 	if (U_IS_BMP(codepoint)) {
 		*buf++ = (UChar) codepoint;
@@ -149,7 +149,7 @@ static inline int zend_codepoint_to_ucha
 
 #define USTR_MAKE(cs) zend_ascii_to_unicode(cs, sizeof(cs) ZEND_FILE_LINE_CC)
 #define USTR_MAKE_REL(cs) zend_ascii_to_unicode(cs, sizeof(cs) ZEND_FILE_LINE_RELAY_CC)
-static inline UChar* zend_ascii_to_unicode(const char *cs, size_t cs_size ZEND_FILE_LINE_DC)
+static always_inline UChar* zend_ascii_to_unicode(const char *cs, size_t cs_size ZEND_FILE_LINE_DC)
 {
 	/* u_charsToUChars() takes care of the terminating NULL */
 	UChar *us = eumalloc_rel(cs_size);
diff -u -p -d -r Zend/zend_variables.h Zend/zend_variables.h
--- Zend/zend_variables.h	2007-10-07 22:31:00.000000000 -0700
+++ Zend/zend_variables.h	2007-10-07 22:22:01.000000000 -0700
@@ -27,7 +27,7 @@ BEGIN_EXTERN_C()
 
 ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC);
 
-static inline void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC)
+static always_inline void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC)
 {
 	if (Z_TYPE_P(zvalue) <= IS_BOOL) {
 		return;
@@ -37,7 +37,7 @@ static inline void _zval_dtor(zval *zval
 
 ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
 
-static inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+static always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
 {
 	Z_SET_BLACK_P(zvalue);
 	Z_UNSET_BUFFERED_P(zvalue);