diff -u -p -d -r Zend/zend_alloc.c Zend/zend_alloc.c
--- Zend/zend_alloc.c	2007-10-07 22:30:44.000000000 -0700
+++ Zend/zend_alloc.c	2007-10-07 22:21:37.000000000 -0700
@@ -650,7 +650,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;
@@ -671,7 +671,7 @@ static inline unsigned int zend_mm_high_
 #endif
 }
 
-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;
@@ -696,7 +696,7 @@ static inline unsigned int zend_mm_low_b
 #endif
 }
 
-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;
 
@@ -713,7 +713,7 @@ static inline void zend_mm_add_to_rest_l
 	prev->next_free_block = next->prev_free_block = mm_block;
 }
 
-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;
@@ -774,7 +774,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;
@@ -845,7 +845,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;
@@ -2280,7 +2280,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 ;
@@ -2300,7 +2300,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:22:02.000000000 -0700
+++ Zend/zend_compile.c	2007-10-07 22:21:37.000000000 -0700
@@ -605,7 +605,7 @@ void zend_do_assign(znode *result, znode
 	*result = opline->result;
 }
 
-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;
 
@@ -646,7 +646,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;
@@ -659,7 +659,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));
@@ -2367,7 +2367,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 %s could not implement interface %s", 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:30:44.000000000 -0700
+++ Zend/zend_execute.c	2007-10-07 22:21:37.000000000 -0700
@@ -64,7 +64,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;
 
@@ -85,7 +85,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)) {
@@ -175,7 +175,7 @@ ZEND_API zval** zend_get_compiled_variab
 	return execute_data_ptr->CVs[var];
 }
 
-static inline void zend_get_cv_address(zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC)
+static always_inline void zend_get_cv_address(zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC)
 {
 	zval *new_zval = &EG(uninitialized_zval);
 
@@ -183,12 +183,12 @@ static inline void zend_get_cv_address(z
 	zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr);
 }
 
-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)
 {
 	zval *ptr = T(node->u.var).var.ptr;
 	if (ptr) {
@@ -223,7 +223,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);
 
@@ -250,7 +250,7 @@ static inline zval *_get_zval_ptr_cv(zno
 	return **ptr;
 }
 
-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) {
@@ -278,7 +278,7 @@ static inline zval *_get_zval_ptr(znode 
 	return NULL;
 }
 
-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;
 
@@ -291,7 +291,7 @@ static inline zval **_get_zval_ptr_ptr_v
 	return ptr_ptr;
 }
 
-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);
 
@@ -318,7 +318,7 @@ static inline zval **_get_zval_ptr_ptr_c
 	return *ptr;
 }
 
-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;
@@ -331,7 +331,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);
@@ -341,7 +341,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)) {
@@ -356,7 +356,7 @@ static inline zval **_get_obj_zval_ptr_p
 	return get_zval_ptr_ptr(op, Ts, should_free, type);
 }
 
-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);
@@ -366,7 +366,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)) {
@@ -379,7 +379,7 @@ static inline zval *_get_obj_zval_ptr(zn
 	return get_zval_ptr(op, Ts, should_free, type);
 }
 
-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:
@@ -462,7 +462,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)
@@ -476,7 +476,7 @@ static inline void make_real_object(zval
 	}
 }
 
-static inline char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC)
+static always_inline char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC)
 {
 	*pce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
 
@@ -488,7 +488,7 @@ static inline char * zend_verify_arg_cla
 	}
 }
 
-static inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, const zend_arg_info *cur_arg_info, const char *need_msg, const char *need_kind, char *given_msg, char *given_kind TSRMLS_DC)
+static always_inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, const zend_arg_info *cur_arg_info, const char *need_msg, const char *need_kind, char *given_msg, char *given_kind TSRMLS_DC)
 {
 	zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
 	char *fname = zf->common.function_name;
@@ -511,7 +511,7 @@ static inline int zend_verify_arg_error(
 	return 0;
 }
 
-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;
@@ -552,7 +552,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;
@@ -660,7 +660,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;
@@ -892,7 +892,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;
 	zval *variable_ptr = *variable_ptr_ptr;
@@ -955,7 +955,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:
@@ -977,7 +977,7 @@ static inline HashTable *zend_get_target
 	return NULL;
 }
 
-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;
 	char *offset_key;
@@ -1352,7 +1352,7 @@ static void zend_fetch_property_address(
 	}
 }
 
-static inline zend_brk_cont_element* zend_brk_cont(zval *nest_levels_zval, int array_offset, zend_op_array *op_array, temp_variable *Ts TSRMLS_DC)
+static always_inline zend_brk_cont_element* zend_brk_cont(zval *nest_levels_zval, int array_offset, zend_op_array *op_array, temp_variable *Ts TSRMLS_DC)
 {
 	zval tmp;
 	int nest_levels, original_nest_levels;
diff -u -p -d -r Zend/zend_execute.h Zend/zend_execute.h
--- Zend/zend_execute.h	2007-09-27 11:00:37.000000000 -0700
+++ Zend/zend_execute.h	2007-10-07 22:21:38.000000000 -0700
@@ -62,7 +62,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();
 
@@ -75,7 +75,7 @@ ZEND_API int zend_lookup_class_ex(const 
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_string_ex(char *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;
 
@@ -143,7 +143,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;
@@ -157,7 +157,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_hash.h Zend/zend_hash.h
--- Zend/zend_hash.h	2007-10-07 22:30:44.000000000 -0700
+++ Zend/zend_hash.h	2007-10-07 22:21:38.000000000 -0700
@@ -252,7 +252,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;
 
@@ -335,34 +335,34 @@ END_EXTERN_C()
 }
 
 
-static inline int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest)					\
+static always_inline int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest)					\
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest));
 	return zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
 }
 
 
-static inline int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength)
+static always_inline int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength)
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx))
 	return zend_hash_del(ht, arKey, nKeyLength);
 }
 
 
-static inline int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
+static always_inline int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
 	return zend_hash_find(ht, arKey, nKeyLength, pData);
 }
 
 
-static inline int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength)
+static always_inline int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength)
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
 	return zend_hash_exists(ht, arKey, nKeyLength);
 }
 
-static inline int zend_symtable_update_current_key(HashTable *ht, const char *arKey, uint nKeyLength)
+static always_inline int zend_symtable_update_current_key(HashTable *ht, const char *arKey, uint nKeyLength)
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_update_current_key(ht, HASH_KEY_IS_LONG, NULL, 0, idx));
 	return zend_hash_update_current_key(ht, HASH_KEY_IS_STRING, arKey, nKeyLength, 0);
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
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:22:03.000000000 -0700
+++ Zend/zend_object_handlers.c	2007-10-07 22:21:37.000000000 -0700
@@ -162,7 +162,7 @@ static int zend_verify_property_access(z
 	return 0;
 }
 
-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) {
@@ -676,7 +676,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, char *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, char *function_name_strval, int function_name_strlen TSRMLS_DC)
 {
 	if (!ce) {
 		return 0;
@@ -746,7 +746,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:22:03.000000000 -0700
+++ Zend/zend_operators.c	2007-10-07 22:21:37.000000000 -0700
@@ -1303,7 +1303,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-10-06 22:22:03.000000000 -0700
+++ Zend/zend_operators.h	2007-10-07 22:21:38.000000000 -0700
@@ -90,7 +90,7 @@ END_EXTERN_C()
  * if that pointer is not NULL.
  */
 
-static inline zend_uchar is_numeric_string(const char *str, int length, long *lval, double *dval, int allow_errors)
+static always_inline zend_uchar is_numeric_string(const char *str, int length, long *lval, double *dval, int allow_errors)
 {
 	const char *ptr;
 	int base = 10, digits = 0, dp_or_e = 0;
@@ -214,7 +214,7 @@ process_double:
 	}
 }
 
-static inline char *
+static always_inline char *
 zend_memnstr(char *haystack, char *needle, int needle_len, char *end)
 {
 	char *p = haystack;
@@ -239,7 +239,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;
 
@@ -290,7 +290,7 @@ ZEND_API void zend_str_tolower(char *str
 ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length);
 END_EXTERN_C()
 
-static inline char *
+static always_inline char *
 zend_str_tolower_dup(const char *source, unsigned int length)
 {
 	return zend_str_tolower_copy((char *)emalloc(length+1), source, length);
diff -u -p -d -r Zend/zend_ptr_stack.h Zend/zend_ptr_stack.h
--- Zend/zend_ptr_stack.h	2007-01-01 01:35:47.000000000 -0800
+++ Zend/zend_ptr_stack.h	2007-10-07 22:21:38.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_variables.h Zend/zend_variables.h
--- Zend/zend_variables.h	2007-01-01 01:35:47.000000000 -0800
+++ Zend/zend_variables.h	2007-10-07 22:21:38.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 (zvalue->type <= 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)
 {
         if (zvalue->type <= IS_BOOL) {
                 return;