Merge branch 'master' of https://git.php.net/push/php-src

* 'master' of https://git.php.net/push/php-src: (6215 commits)
  Extra comma
  Moved proxy object support in ASSIGN_ADD (and family) from VM to slow paths of corresponding operators
  Simplification
  zend_get_property_info_quick() cleanup and optimization
  initialize lineno before calling compile file file in phar
  Use ADDREF instead of DUP, it must be enough.
  Removed old irrelevant comment
  fixed compilation error
  Fix bug #68262: Broken reference across cloned objects
  export functions needed for phpdbg
  Fixed compilation
  Optimized property access handlers. Removed EG(std_property_info).
  Fixed bug #68199 (PDO::pgsqlGetNotify doesn't support NOTIFY payloads)
  Don't make difference between undefined and unaccessible properies when call __get() and family
  Don't make useless CSE
  array_pop/array_shift optimization
  check for zlib headers as well as lib for mysqlnd
  a realpath cache key can be int or float, catching this
  News entry for new curl constants
  News entry for new curl constants
  ...

1 files changed, 138 insertions, 242 deletions

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index b68a82ef89..95421191f0 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -2,7 +2,7 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
    | This source file is subject to version 2.00 of the Zend license,     |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -27,79 +27,62 @@
 #include "zend_operators.h"
 #include "zend_variables.h"
 
-typedef union _temp_variable {
-	zval tmp_var;
-	struct {
-		zval **ptr_ptr;
-		zval *ptr;
-		zend_bool fcall_returned_reference;
-	} var;
-	struct {
-		zval **ptr_ptr; /* shared with var.ptr_ptr */
-		zval *str;
-		zend_uint offset;
-	} str_offset;
-	struct {
-		zval **ptr_ptr; /* shared with var.ptr_ptr */
-		zval *ptr;      /* shared with var.ptr */
-		HashPointer fe_pos;
-	} fe;
-	zend_class_entry *class_entry;
-} temp_variable;
-
-
 BEGIN_EXTERN_C()
 struct _zend_fcall_info;
 ZEND_API extern void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data, zval *return_value TSRMLS_DC);
 
 void init_executor(TSRMLS_D);
 void shutdown_executor(TSRMLS_D);
 void shutdown_destructors(TSRMLS_D);
-zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zend_bool nested TSRMLS_DC);
-ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC);
+ZEND_API void zend_init_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value TSRMLS_DC);
+ZEND_API zend_execute_data *zend_create_generator_execute_data(zend_execute_data *call, zend_op_array *op_array, zval *return_value TSRMLS_DC);
+ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC);
 ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
-ZEND_API int zend_is_true(zval *op);
-ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API void execute_internal(zend_execute_data *execute_data, zval *return_value TSRMLS_DC);
+ZEND_API int zend_is_true(zval *op TSRMLS_DC);
+ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC);
+ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC);
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_stringl(char *str, int str_len, 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);
 ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 
-ZEND_API 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);
-ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, zend_ulong fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC);
+ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, uint32_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind, zval *arg TSRMLS_DC);
 
 static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_DC)
 {
-	if (!Z_DELREF_P(zval_ptr)) {
-		ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
-		GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr);
-		zval_dtor(zval_ptr);
-		efree_rel(zval_ptr);
-	} else {
-		if (Z_REFCOUNT_P(zval_ptr) == 1) {
-			Z_UNSET_ISREF_P(zval_ptr);
+	if (Z_REFCOUNTED_P(zval_ptr)) {
+		if (!Z_DELREF_P(zval_ptr)) {
+			ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
+			_zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
+		} else {
+			GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
 		}
-
-		GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
 	}
 }
 
-static zend_always_inline int i_zend_is_true(zval *op)
+static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 {
 	int result;
 
+again:
 	switch (Z_TYPE_P(op)) {
+		case IS_UNDEF:
 		case IS_NULL:
+		case IS_FALSE:
 			result = 0;
 			break;
+		case IS_TRUE:
+			result = 1;
+			break;
 		case IS_LONG:
-		case IS_BOOL:
-		case IS_RESOURCE:
 			result = (Z_LVAL_P(op)?1:0);
 			break;
+		case IS_RESOURCE:
+			result = (Z_RES_HANDLE_P(op)?1:0);
+			break;
 		case IS_DOUBLE:
 			result = (Z_DVAL_P(op) ? 1 : 0);
 			break;
@@ -115,28 +98,30 @@ static zend_always_inline int i_zend_is_true(zval *op)
 			result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			break;
 		case IS_OBJECT:
-			if(IS_ZEND_STD_OBJECT(*op)) {
-				TSRMLS_FETCH();
-
-				if (Z_OBJ_HT_P(op)->cast_object) {
-					zval tmp;
-					if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
-						result = Z_LVAL(tmp);
-						break;
-					}
-				} else if (Z_OBJ_HT_P(op)->get) {
-					zval *tmp = Z_OBJ_HT_P(op)->get(op TSRMLS_CC);
-					if(Z_TYPE_P(tmp) != IS_OBJECT) {
-						/* for safety - avoid loop */
-						convert_to_boolean(tmp);
-						result = Z_LVAL_P(tmp);
-						zval_ptr_dtor(&tmp);
-						break;
-					}
+			if (Z_OBJ_HT_P(op)->cast_object) {
+				zval tmp;
+				if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL TSRMLS_CC) == SUCCESS) {
+					result = Z_TYPE(tmp) == IS_TRUE;
+					break;
+				}
+				zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to boolean", Z_OBJ_P(op)->ce->name->val);
+			} else if (Z_OBJ_HT_P(op)->get) {
+				zval rv;
+				zval *tmp = Z_OBJ_HT_P(op)->get(op, &rv TSRMLS_CC);
+				if (Z_TYPE_P(tmp) != IS_OBJECT) {
+					/* for safety - avoid loop */
+					convert_to_boolean(tmp);
+					result = Z_TYPE_P(tmp) == IS_TRUE;
+					zval_ptr_dtor(tmp);
+					break;
 				}
 			}
 			result = 1;
 			break;
+		case IS_REFERENCE:
+			op = Z_REFVAL_P(op);
+			goto again;
+			break;
 		default:
 			result = 0;
 			break;
@@ -144,196 +129,101 @@ static zend_always_inline int i_zend_is_true(zval *op)
 	return result;
 }
 
-ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_inline_change(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_no_inline_change(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant(zval *pp, zend_bool inline_change TSRMLS_DC);
+ZEND_API int zval_update_constant_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_no_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_ex(zval *pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC);
 
 /* dedicated Zend executor functions - do not use! */
-#define ZEND_VM_STACK_PAGE_SIZE ((16 * 1024) - 16)
-
 struct _zend_vm_stack {
-	void **top;
-	void **end;
+	zval *top;
+	zval *end;
 	zend_vm_stack prev;
 };
 
-#define ZEND_VM_STACK_ELEMETS(stack) \
-	((void**)(((char*)(stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(struct _zend_vm_stack))))
-
-#define ZEND_VM_STACK_GROW_IF_NEEDED(count)							\
-	do {															\
-		if (UNEXPECTED((count) >									\
-		    EG(argument_stack)->end - EG(argument_stack)->top)) {	\
-			zend_vm_stack_extend((count) TSRMLS_CC);				\
-		}															\
-	} while (0)
-
-static zend_always_inline zend_vm_stack zend_vm_stack_new_page(int count) {
-	zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(void*) * count);
+#define ZEND_VM_STACK_HEADER_SLOTS \
+	((ZEND_MM_ALIGNED_SIZE(sizeof(struct _zend_vm_stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval)) - 1) / ZEND_MM_ALIGNED_SIZE(sizeof(zval)))
 
-	page->top = ZEND_VM_STACK_ELEMETS(page);
-	page->end = page->top + count;
-	page->prev = NULL;
-	return page;
-}
+#define ZEND_VM_STACK_ELEMETS(stack) \
+	(((zval*)(stack)) + ZEND_VM_STACK_HEADER_SLOTS)
 
-static zend_always_inline void zend_vm_stack_init(TSRMLS_D)
-{
-	EG(argument_stack) = zend_vm_stack_new_page(ZEND_VM_STACK_PAGE_SIZE);
-}
+ZEND_API void zend_vm_stack_init(TSRMLS_D);
+ZEND_API void zend_vm_stack_destroy(TSRMLS_D);
+ZEND_API void* zend_vm_stack_extend(size_t size TSRMLS_DC);
 
-static zend_always_inline void zend_vm_stack_destroy(TSRMLS_D)
+static zend_always_inline zval* zend_vm_stack_alloc(size_t size TSRMLS_DC)
 {
-	zend_vm_stack stack = EG(argument_stack);
+	char *top = (char*)EG(vm_stack_top);
 
-	while (stack != NULL) {
-		zend_vm_stack p = stack->prev;
-		efree(stack);
-		stack = p;
+	if (UNEXPECTED(size > (size_t)(((char*)EG(vm_stack_end)) - top))) {
+		return (zval*)zend_vm_stack_extend(size TSRMLS_CC);
 	}
+	EG(vm_stack_top) = (zval*)(top + size);
+	return (zval*)top;
 }
 
-static zend_always_inline void zend_vm_stack_extend(int count TSRMLS_DC)
+static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint32_t frame_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev TSRMLS_DC)
 {
-	zend_vm_stack p = zend_vm_stack_new_page(count >= ZEND_VM_STACK_PAGE_SIZE ? count : ZEND_VM_STACK_PAGE_SIZE);
-	p->prev = EG(argument_stack);
-	EG(argument_stack) = p;
-}
-
-static zend_always_inline void **zend_vm_stack_top(TSRMLS_D)
-{
-	return EG(argument_stack)->top;
-}
-
-static zend_always_inline void zend_vm_stack_push(void *ptr TSRMLS_DC)
-{
-	*(EG(argument_stack)->top++) = ptr;
-}
-
-static zend_always_inline void *zend_vm_stack_pop(TSRMLS_D)
-{
-	void *el = *(--EG(argument_stack)->top);
-
-	return el;
-}
-
-static zend_always_inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
-{
-	void *ret;
-
-	size = (size + (sizeof(void*) - 1)) / sizeof(void*);
-
-	/* the following comparison must be optimized out at compile time */
-	if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
-		int extra = (ZEND_MM_ALIGNMENT - ((zend_uintptr_t)EG(argument_stack)->top & (ZEND_MM_ALIGNMENT - 1))) / sizeof(void*);
-
-		if (UNEXPECTED(size + extra + ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*) >
-		    (zend_uintptr_t)(EG(argument_stack)->end - EG(argument_stack)->top))) {
-			zend_vm_stack_extend(size TSRMLS_CC);
-		} else {
-			void **old_top = EG(argument_stack)->top;
-
-			EG(argument_stack)->top += extra;
-			/* store old top on the stack */
-			*EG(argument_stack)->top = (void*)old_top;
-			EG(argument_stack)->top += ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*);
-		}
-	} else {
-		ZEND_VM_STACK_GROW_IF_NEEDED((int)size);
+	uint32_t used_stack = ZEND_CALL_FRAME_SLOT + num_args;
+	zend_execute_data *call;
+	
+	if (ZEND_USER_CODE(func->type)) {
+		used_stack += func->op_array.last_var + func->op_array.T - MIN(func->op_array.num_args, num_args);
 	}
-	ret = (void*)EG(argument_stack)->top;
-	EG(argument_stack)->top += size;
-	return ret;
+	call = (zend_execute_data*)zend_vm_stack_alloc(used_stack * sizeof(zval) TSRMLS_CC);
+	call->func = func;
+	ZVAL_OBJ(&call->This, object);
+	call->called_scope = called_scope;
+	call->prev_execute_data = prev;
+	call->frame_info = frame_info;
+	call->num_args = 0;
+	return call;
 }
 
-static zend_always_inline void** zend_vm_stack_frame_base(zend_execute_data *ex)
+static zend_always_inline void zend_vm_stack_free_extra_args(zend_execute_data *call TSRMLS_DC)
 {
-	return (void**)((char*)ex->call_slots +
-		ZEND_MM_ALIGNED_SIZE(sizeof(call_slot)) * ex->op_array->nested_calls);
+	uint32_t first_extra_arg = call->func->op_array.num_args - ((call->func->common.fn_flags & ZEND_ACC_VARIADIC) != 0);
+
+ 	if (UNEXPECTED(call->num_args > first_extra_arg)) {
+ 		zval *end = EX_VAR_NUM_2(call, call->func->op_array.last_var + call->func->op_array.T);
+ 		zval *p = end + (call->num_args - first_extra_arg);
+		do {
+			p--;
+			zval_ptr_dtor_nogc(p);
+		} while (p != end);
+ 	}
 }
 
-static zend_always_inline void zend_vm_stack_free_int(void *ptr TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_free_args(zend_execute_data *call TSRMLS_DC)
 {
-	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
-		zend_vm_stack p = EG(argument_stack);
+	uint32_t num_args = call->num_args;	
 
-		EG(argument_stack) = p->prev;
-		efree(p);
-	} else {
-		EG(argument_stack)->top = (void**)ptr;
-	}
-}
-
-static zend_always_inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
-{
-	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
-		zend_vm_stack p = EG(argument_stack);
+	if (num_args > 0) {
+		zval *end = ZEND_CALL_ARG(call, 1);
+		zval *p = end + num_args;
 
-		EG(argument_stack) = p->prev;
-		efree(p);
-	} else {
-		/* the following comparison must be optimized out at compile time */
-		if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
-			ptr = (void*)(((char*)ptr) - ZEND_MM_ALIGNED_SIZE(sizeof(void*)));
-			EG(argument_stack)->top = *(void***)ptr;
-		} else {
-			EG(argument_stack)->top = (void**)ptr;
-		}
+		do {
+			p--;
+			zval_ptr_dtor_nogc(p);
+		} while (p != end);
 	}
 }
 
-static zend_always_inline void zend_vm_stack_clear_multiple(int nested TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_free_call_frame(zend_execute_data *call TSRMLS_DC)
 {
-	void **p = EG(argument_stack)->top - 1;
- 	void **end = p - (int)(zend_uintptr_t)*p;
-
-	while (p != end) {
-		zval *q = (zval *) *(--p);
-		*p = NULL;
-		i_zval_ptr_dtor(q ZEND_FILE_LINE_CC TSRMLS_CC);
-	}
-	if (nested) {
-		EG(argument_stack)->top = p;
-	} else {
-		zend_vm_stack_free_int(p TSRMLS_CC);
-	}
-}
+	zend_vm_stack p = EG(vm_stack);
+	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(p) == (zval*)call)) {
+		zend_vm_stack prev = p->prev;
 
-static zend_always_inline int zend_vm_stack_get_args_count_ex(zend_execute_data *ex)
-{
-	if (ex) {
-		void **p = ex->function_state.arguments;
-		return (int)(zend_uintptr_t) *p;
+		EG(vm_stack_top) = prev->top;
+		EG(vm_stack_end) = prev->end;
+		EG(vm_stack) = prev;
+		efree(p);
 	} else {
-		return 0;			
-	}
-}
-
-static zend_always_inline zval** zend_vm_stack_get_arg_ex(zend_execute_data *ex, int requested_arg)
-{
-	void **p = ex->function_state.arguments;
-	int arg_count = (int)(zend_uintptr_t) *p;
-
-	if (UNEXPECTED(requested_arg > arg_count)) {
-		return NULL;
+		EG(vm_stack_top) = (zval*)call;
 	}
-	return (zval**)p - arg_count + requested_arg - 1;
-}
-
-static zend_always_inline int zend_vm_stack_get_args_count(TSRMLS_D)
-{
-	return zend_vm_stack_get_args_count_ex(EG(current_execute_data)->prev_execute_data);
-}
-
-static zend_always_inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
-{
-	return zend_vm_stack_get_arg_ex(EG(current_execute_data)->prev_execute_data, requested_arg);
 }
 
-void execute_new_code(TSRMLS_D);
-
-
 /* services */
 ZEND_API const char *get_active_class_name(const char **space TSRMLS_DC);
 ZEND_API const char *get_active_function_name(TSRMLS_D);
@@ -341,13 +231,15 @@ ZEND_API const char *zend_get_executed_filename(TSRMLS_D);
 ZEND_API uint zend_get_executed_lineno(TSRMLS_D);
 ZEND_API zend_bool zend_is_executing(TSRMLS_D);
 
-ZEND_API void zend_set_timeout(long seconds, int reset_signals);
+ZEND_API void zend_set_timeout(zend_long seconds, int reset_signals);
 ZEND_API void zend_unset_timeout(TSRMLS_D);
 ZEND_API void zend_timeout(int dummy);
-ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
-ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type TSRMLS_DC);
 void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
 
+ZEND_API void zend_fetch_dimension_by_zval(zval *result, zval *container, zval *dim TSRMLS_DC);
+
 #ifdef ZEND_WIN32
 void zend_init_timeout_thread(void);
 void zend_shutdown_timeout_thread(void);
@@ -355,17 +247,7 @@ void zend_shutdown_timeout_thread(void);
 #define WM_UNREGISTER_ZEND_TIMEOUT		(WM_USER+2)
 #endif
 
-#define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p))
-#define zendi_zval_dtor(p) zval_dtor(&(p))
-
-#define active_opline (*EG(opline_ptr))
-
-/* The following tries to resolve the classname of a zval of type object.
- * Since it is slow it should be only used in error messages.
- */
-#define Z_OBJ_CLASS_NAME_P(zval) ((zval) && Z_TYPE_P(zval) == IS_OBJECT && Z_OBJ_HT_P(zval)->get_class_entry != NULL && Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC) ? Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC)->name : "")
-
-ZEND_API zval** zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, zend_uint var);
+ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, uint32_t var);
 
 #define ZEND_USER_OPCODE_CONTINUE   0 /* execute next opcode */
 #define ZEND_USER_OPCODE_RETURN     1 /* exit from executor (return from function) */
@@ -380,33 +262,47 @@ ZEND_API user_opcode_handler_t zend_get_user_opcode_handler(zend_uchar opcode);
 
 /* former zend_execute_locks.h */
 typedef struct _zend_free_op {
-	zval* var;
+	zval *var;
 /*	int   is_var; */
 } zend_free_op;
 
 ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC);
-ZEND_API zval **zend_get_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC);
 
 ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS);
 
-void zend_clean_and_cache_symbol_table(HashTable *symbol_table TSRMLS_DC);
+ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table TSRMLS_DC);
 void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC);
 
 #define CACHED_PTR(num) \
-	EG(active_op_array)->run_time_cache[(num)]
+	EX(run_time_cache)[(num)]
 
 #define CACHE_PTR(num, ptr) do { \
-		EG(active_op_array)->run_time_cache[(num)] = (ptr); \
+		EX(run_time_cache)[(num)] = (ptr); \
 	} while (0)
 
 #define CACHED_POLYMORPHIC_PTR(num, ce) \
-	((EG(active_op_array)->run_time_cache[(num)] == (ce)) ? \
-		EG(active_op_array)->run_time_cache[(num) + 1] : \
+	((EX(run_time_cache)[(num)] == (ce)) ? \
+		EX(run_time_cache)[(num) + 1] : \
 		NULL)
 
 #define CACHE_POLYMORPHIC_PTR(num, ce, ptr) do { \
-		EG(active_op_array)->run_time_cache[(num)] = (ce); \
-		EG(active_op_array)->run_time_cache[(num) + 1] = (ptr); \
+		EX(run_time_cache)[(num)] = (ce); \
+		EX(run_time_cache)[(num) + 1] = (ptr); \
+	} while (0)
+
+#define CACHED_PTR_EX(slot) \
+	(slot)[0]
+
+#define CACHE_PTR_EX(slot, ptr) do { \
+		(slot)[0] = (ptr); \
+	} while (0)
+
+#define CACHED_POLYMORPHIC_PTR_EX(slot, ce) \
+	(((slot)[0] == (ce)) ? (slot)[1] : NULL)
+
+#define CACHE_POLYMORPHIC_PTR_EX(slot, ce, ptr) do { \
+		(slot)[0] = (ce); \
+		(slot)[1] = (ptr); \
 	} while (0)
 
 END_EXTERN_C()