zend_execute_API.c

/*
 +----------------------------------------------------------------------+
 | Zend Engine |
 +----------------------------------------------------------------------+
 | Copyright (c) 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 |
 | available through the world-wide-web at the following url: |
 | http://www.zend.com/license/2_00.txt. |
 | If you did not receive a copy of the Zend license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@zend.com so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 | Dmitry Stogov <dmitry@php.net> |
 +----------------------------------------------------------------------+
*/

#include<stdio.h>
#include<signal.h>

#include"zend.h"
#include"zend_compile.h"
#include"zend_execute.h"
#include"zend_API.h"
#include"zend_stack.h"
#include"zend_constants.h"
#include"zend_extensions.h"
#include"zend_exceptions.h"
#include"zend_closures.h"
#include"zend_generators.h"
#include"zend_vm.h"
#include"zend_float.h"
#include"zend_fibers.h"
#include"zend_weakrefs.h"
#include"zend_inheritance.h"
#include"zend_observer.h"
#include"zend_call_stack.h"
#include"zend_frameless_function.h"
#ifdefHAVE_SYS_TIME_H
#include<sys/time.h>
#endif
#ifdefHAVE_UNISTD_H
#include<unistd.h>
#endif
#ifdefZEND_MAX_EXECUTION_TIMERS
#include<sys/syscall.h>
#endif

ZEND_APIvoid (*zend_execute_ex)(zend_execute_data*execute_data);
ZEND_APIvoid (*zend_execute_internal)(zend_execute_data*execute_data, zval*return_value);
ZEND_APIzend_class_entry*(*zend_autoload)(zend_string*name, zend_string*lc_name);

#ifdefZEND_WIN32
ZEND_TLSHANDLEtq_timer=NULL;
#endif

#if0&&ZEND_DEBUG
staticvoid (*original_sigsegv_handler)(int);
staticvoidzend_handle_sigsegv(void) /* {{{ */
{
fflush(stdout);
fflush(stderr);
if (original_sigsegv_handler==zend_handle_sigsegv) {
signal(SIGSEGV, original_sigsegv_handler);
 } else {
signal(SIGSEGV, SIG_DFL);
 }
 {

fprintf(stderr, "SIGSEGV caught on opcode %d on opline %d of %s() at %s:%d\n\n",
active_opline->opcode,
active_opline-EG(active_op_array)->opcodes,
get_active_function_name(),
zend_get_executed_filename(),
zend_get_executed_lineno());
/* See http://support.microsoft.com/kb/190351 */
#ifdefZEND_WIN32
fflush(stderr);
#endif
 }
if (original_sigsegv_handler!=zend_handle_sigsegv) {
original_sigsegv_handler(dummy);
 }
}
/* }}} */
#endif

staticvoidzend_extension_activator(zend_extension*extension) /* {{{ */
{
if (extension->activate) {
extension->activate();
 }
}
/* }}} */

staticvoidzend_extension_deactivator(zend_extension*extension) /* {{{ */
{
if (extension->deactivate) {
extension->deactivate();
 }
}
/* }}} */

staticintclean_non_persistent_constant_full(zval*zv) /* {{{ */
{
zend_constant*c=Z_PTR_P(zv);
return (ZEND_CONSTANT_FLAGS(c) &CONST_PERSISTENT) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
}
/* }}} */

staticintclean_non_persistent_function_full(zval*zv) /* {{{ */
{
zend_function*function=Z_PTR_P(zv);
return (function->type==ZEND_INTERNAL_FUNCTION) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
}
/* }}} */

staticintclean_non_persistent_class_full(zval*zv) /* {{{ */
{
zend_class_entry*ce=Z_PTR_P(zv);
return (ce->type==ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
}
/* }}} */

voidinit_executor(void) /* {{{ */
{
zend_init_fpu();

ZVAL_NULL(&EG(uninitialized_zval));
ZVAL_ERROR(&EG(error_zval));
/* destroys stack frame, therefore makes core dumps worthless */
#if0&&ZEND_DEBUG
original_sigsegv_handler=signal(SIGSEGV, zend_handle_sigsegv);
#endif

ZVAL_UNDEF(&EG(last_fatal_error_backtrace));

EG(symtable_cache_ptr) =EG(symtable_cache);
EG(symtable_cache_limit) =EG(symtable_cache) +SYMTABLE_CACHE_SIZE;
EG(no_extensions) =0;

EG(function_table) =CG(function_table);
EG(class_table) =CG(class_table);

EG(in_autoload) =NULL;
EG(error_handling) =EH_NORMAL;
EG(flags) =EG_FLAGS_INITIAL;

zend_vm_stack_init();

zend_hash_init(&EG(symbol_table), 64, NULL, ZVAL_PTR_DTOR, 0);

zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator);

zend_hash_init(&EG(included_files), 8, NULL, NULL, 0);

EG(ticks_count) =0;

ZVAL_UNDEF(&EG(user_error_handler));
ZVAL_UNDEF(&EG(user_exception_handler));

EG(current_execute_data) =NULL;

zend_stack_init(&EG(user_error_handlers_error_reporting), sizeof(int));
zend_stack_init(&EG(user_error_handlers), sizeof(zval));
zend_stack_init(&EG(user_exception_handlers), sizeof(zval));

zend_objects_store_init(&EG(objects_store), 1024);
zend_lazy_objects_init(&EG(lazy_objects_store));

EG(full_tables_cleanup) =0;
ZEND_ATOMIC_BOOL_INIT(&EG(vm_interrupt), false);
ZEND_ATOMIC_BOOL_INIT(&EG(timed_out), false);

EG(exception) =NULL;
EG(prev_exception) =NULL;

EG(fake_scope) =NULL;
EG(trampoline).common.function_name=NULL;

EG(ht_iterators_count) =sizeof(EG(ht_iterators_slots)) / sizeof(HashTableIterator);
EG(ht_iterators_used) =0;
EG(ht_iterators) =EG(ht_iterators_slots);
memset(EG(ht_iterators), 0, sizeof(EG(ht_iterators_slots)));

EG(persistent_constants_count) =EG(zend_constants)->nNumUsed;
EG(persistent_functions_count) =EG(function_table)->nNumUsed;
EG(persistent_classes_count) =EG(class_table)->nNumUsed;

EG(get_gc_buffer).start=EG(get_gc_buffer).end=EG(get_gc_buffer).cur=NULL;

EG(record_errors) = false;
EG(num_errors) =0;
EG(errors) =NULL;

EG(filename_override) =NULL;
EG(lineno_override) =-1;

zend_max_execution_timer_init();
zend_fiber_init();
zend_weakrefs_init();

EG(active) =1;
}
/* }}} */

staticintzval_call_destructor(zval*zv) /* {{{ */
{
if (Z_TYPE_P(zv) ==IS_INDIRECT) {
zv=Z_INDIRECT_P(zv);
 }
if (Z_TYPE_P(zv) ==IS_OBJECT&&Z_REFCOUNT_P(zv) ==1) {
returnZEND_HASH_APPLY_REMOVE;
 } else {
returnZEND_HASH_APPLY_KEEP;
 }
}
/* }}} */

staticvoidzend_unclean_zval_ptr_dtor(zval*zv) /* {{{ */
{
if (Z_TYPE_P(zv) ==IS_INDIRECT) {
zv=Z_INDIRECT_P(zv);
 }
i_zval_ptr_dtor(zv);
}
/* }}} */

staticZEND_COLDvoidzend_throw_or_error(intfetch_type, zend_class_entry*exception_ce, constchar*format, ...) /* {{{ */
{
va_listva;
char*message=NULL;

va_start(va, format);
zend_vspprintf(&message, 0, format, va);

if (fetch_type&ZEND_FETCH_CLASS_EXCEPTION) {
zend_throw_error(exception_ce, "%s", message);
 } else {
zend_error_noreturn(E_ERROR, "%s", message);
 }

efree(message);
va_end(va);
}
/* }}} */

voidshutdown_destructors(void) /* {{{ */
{
if (CG(unclean_shutdown)) {
EG(symbol_table).pDestructor=zend_unclean_zval_ptr_dtor;
 }
zend_try {
uint32_tsymbols;
do {
symbols=zend_hash_num_elements(&EG(symbol_table));
zend_hash_reverse_apply(&EG(symbol_table), (apply_func_t) zval_call_destructor);
 } while (symbols!=zend_hash_num_elements(&EG(symbol_table)));
zend_objects_store_call_destructors(&EG(objects_store));
 } zend_catch {
/* if we couldn't destruct cleanly, mark all objects as destructed anyway */
zend_objects_store_mark_destructed(&EG(objects_store));
 } zend_end_try();
}
/* }}} */

/* Free values held by the executor. */
ZEND_APIvoidzend_shutdown_executor_values(boolfast_shutdown)
{
zend_string*key;
zval*zv;

EG(flags) |= EG_FLAGS_IN_RESOURCE_SHUTDOWN;
zend_try {
zend_close_rsrc_list(&EG(regular_list));
 } zend_end_try();

/* No PHP callback functions should be called after this point. */
EG(active) =0;

if (!fast_shutdown) {
zend_hash_graceful_reverse_destroy(&EG(symbol_table));

/* Constants may contain objects, destroy them before the object store. */
if (EG(full_tables_cleanup)) {
zend_hash_reverse_apply(EG(zend_constants), clean_non_persistent_constant_full);
 } else {
ZEND_HASH_MAP_REVERSE_FOREACH_STR_KEY_VAL(EG(zend_constants), key, zv) {
zend_constant*c=Z_PTR_P(zv);
if (_idx==EG(persistent_constants_count)) {
break;
 }
zval_ptr_dtor_nogc(&c->value);
if (c->name) {
zend_string_release_ex(c->name, 0);
 }
if (c->filename) {
zend_string_release_ex(c->filename, 0);
 }
if (c->attributes) {
zend_hash_release(c->attributes);
 }
efree(c);
zend_string_release_ex(key, 0);
 } ZEND_HASH_MAP_FOREACH_END_DEL();
 }

zval_ptr_dtor(&EG(last_fatal_error_backtrace));
ZVAL_UNDEF(&EG(last_fatal_error_backtrace));

/* Release static properties and static variables prior to the final GC run,
 * as they may hold GC roots. */
ZEND_HASH_MAP_REVERSE_FOREACH_VAL(EG(function_table), zv) {
zend_op_array*op_array=Z_PTR_P(zv);
if (op_array->type==ZEND_INTERNAL_FUNCTION) {
break;
 }
if (ZEND_MAP_PTR(op_array->static_variables_ptr)) {
HashTable*ht=ZEND_MAP_PTR_GET(op_array->static_variables_ptr);
if (ht) {
zend_array_destroy(ht);
ZEND_MAP_PTR_SET(op_array->static_variables_ptr, NULL);
 }
 }
 } ZEND_HASH_FOREACH_END();
ZEND_HASH_MAP_REVERSE_FOREACH_VAL(EG(class_table), zv) {
zend_class_entry*ce=Z_PTR_P(zv);

if (ce->default_static_members_count) {
zend_cleanup_internal_class_data(ce);
 }

if (ZEND_MAP_PTR(ce->mutable_data)) {
if (ZEND_MAP_PTR_GET_IMM(ce->mutable_data)) {
zend_cleanup_mutable_class_data(ce);
 }
 } elseif (ce->type==ZEND_USER_CLASS&& !(ce->ce_flags&ZEND_ACC_IMMUTABLE)) {
/* Constants may contain objects, destroy the values before the object store. */
zend_class_constant*c;
ZEND_HASH_MAP_FOREACH_PTR(&ce->constants_table, c) {
if (c->ce==ce) {
zval_ptr_dtor_nogc(&c->value);
ZVAL_UNDEF(&c->value);
 }
 } ZEND_HASH_FOREACH_END();

/* properties may contain objects as well */
if (ce->default_properties_table) {
zval*p=ce->default_properties_table;
zval*end=p+ce->default_properties_count;

while (p!=end) {
i_zval_ptr_dtor(p);
ZVAL_UNDEF(p);
p++;
 }
 }
 }

if (ce->type==ZEND_USER_CLASS&&ce->backed_enum_table) {
ZEND_ASSERT(!(ce->ce_flags&ZEND_ACC_IMMUTABLE));
zend_hash_release(ce->backed_enum_table);
ce->backed_enum_table=NULL;
 }

if (ce->ce_flags&ZEND_HAS_STATIC_IN_METHODS) {
zend_op_array*op_array;
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, op_array) {
if (op_array->type==ZEND_USER_FUNCTION) {
if (ZEND_MAP_PTR(op_array->static_variables_ptr)) {
HashTable*ht=ZEND_MAP_PTR_GET(op_array->static_variables_ptr);
if (ht) {
zend_array_destroy(ht);
ZEND_MAP_PTR_SET(op_array->static_variables_ptr, NULL);
 }
 }
 }
 } ZEND_HASH_FOREACH_END();

if (ce->num_hooked_props) {
zend_property_info*prop_info;
ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop_info) {
if (prop_info->ce==ce) {
if (prop_info->hooks) {
for (uint32_ti=0; i<ZEND_PROPERTY_HOOK_COUNT; i++) {
if (prop_info->hooks[i]) {
ZEND_ASSERT(ZEND_USER_CODE(prop_info->hooks[i]->type));
op_array=&prop_info->hooks[i]->op_array;
if (ZEND_MAP_PTR(op_array->static_variables_ptr)) {
HashTable*ht=ZEND_MAP_PTR_GET(op_array->static_variables_ptr);
if (ht) {
zend_array_destroy(ht);
ZEND_MAP_PTR_SET(op_array->static_variables_ptr, NULL);
 }
 }
 }
 }
 }
 }
 } ZEND_HASH_FOREACH_END();
 }
 }
 } ZEND_HASH_FOREACH_END();

/* Also release error and exception handlers, which may hold objects. */
if (Z_TYPE(EG(user_error_handler)) !=IS_UNDEF) {
zval_ptr_dtor(&EG(user_error_handler));
ZVAL_UNDEF(&EG(user_error_handler));
 }

if (Z_TYPE(EG(user_exception_handler)) !=IS_UNDEF) {
zval_ptr_dtor(&EG(user_exception_handler));
ZVAL_UNDEF(&EG(user_exception_handler));
 }

zend_stack_clean(&EG(user_error_handlers_error_reporting), NULL, 1);
zend_stack_clean(&EG(user_error_handlers), (void (*)(void*))ZVAL_PTR_DTOR, 1);
zend_stack_clean(&EG(user_exception_handlers), (void (*)(void*))ZVAL_PTR_DTOR, 1);

#ifZEND_DEBUG
if (!CG(unclean_shutdown)) {
gc_collect_cycles();
 }
#endif
 } else {
zend_hash_discard(EG(zend_constants), EG(persistent_constants_count));
 }

zend_objects_store_free_object_storage(&EG(objects_store), fast_shutdown);
}

voidshutdown_executor(void) /* {{{ */
{
zend_string*key;
zval*zv;
#ifZEND_DEBUG
boolfast_shutdown=0;
#else
boolfast_shutdown=is_zend_mm() && !EG(full_tables_cleanup);
#endif

zend_try {
zend_stream_shutdown();
 } zend_end_try();

zend_shutdown_executor_values(fast_shutdown);

zend_weakrefs_shutdown();
zend_max_execution_timer_shutdown();
zend_fiber_shutdown();

zend_try {
zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_deactivator);
 } zend_end_try();

if (fast_shutdown) {
/* Fast Request Shutdown
 * =====================
 * Zend Memory Manager frees memory by its own. We don't have to free
 * each allocated block separately.
 */
zend_hash_discard(EG(function_table), EG(persistent_functions_count));
zend_hash_discard(EG(class_table), EG(persistent_classes_count));
 } else {
zend_vm_stack_destroy();

if (EG(full_tables_cleanup)) {
zend_hash_reverse_apply(EG(function_table), clean_non_persistent_function_full);
zend_hash_reverse_apply(EG(class_table), clean_non_persistent_class_full);
 } else {
ZEND_HASH_MAP_REVERSE_FOREACH_STR_KEY_VAL(EG(function_table), key, zv) {
zend_function*func=Z_PTR_P(zv);
if (_idx==EG(persistent_functions_count)) {
break;
 }
destroy_op_array(&func->op_array);
zend_string_release_ex(key, 0);
 } ZEND_HASH_MAP_FOREACH_END_DEL();

ZEND_HASH_MAP_REVERSE_FOREACH_STR_KEY_VAL(EG(class_table), key, zv) {
if (_idx==EG(persistent_classes_count)) {
break;
 }
destroy_zend_class(zv);
zend_string_release_ex(key, 0);
 } ZEND_HASH_MAP_FOREACH_END_DEL();
 }

while (EG(symtable_cache_ptr) >EG(symtable_cache)) {
EG(symtable_cache_ptr)--;
zend_hash_destroy(*EG(symtable_cache_ptr));
FREE_HASHTABLE(*EG(symtable_cache_ptr));
 }

zend_hash_destroy(&EG(included_files));

zend_stack_destroy(&EG(user_error_handlers_error_reporting));
zend_stack_destroy(&EG(user_error_handlers));
zend_stack_destroy(&EG(user_exception_handlers));
zend_lazy_objects_destroy(&EG(lazy_objects_store));
zend_objects_store_destroy(&EG(objects_store));
if (EG(in_autoload)) {
zend_hash_destroy(EG(in_autoload));
FREE_HASHTABLE(EG(in_autoload));
 }

if (EG(ht_iterators) !=EG(ht_iterators_slots)) {
efree(EG(ht_iterators));
 }
 }

#ifZEND_DEBUG
if (EG(ht_iterators_used) && !CG(unclean_shutdown)) {
zend_error(E_WARNING, "Leaked %"PRIu32" hashtable iterators", EG(ht_iterators_used));
 }
#endif

/* Check whether anyone is hogging the trampoline. */
ZEND_ASSERT(EG(trampoline).common.function_name==NULL||CG(unclean_shutdown));

EG(ht_iterators_used) =0;

zend_shutdown_fpu();
}
/* }}} */

/* return class name and "::" or "". */
ZEND_APIconstchar*get_active_class_name(constchar**space) /* {{{ */
{
zend_function*func;

if (!zend_is_executing()) {
if (space) {
*space="";
 }
return"";
 }

func=zend_active_function();

switch (func->type) {
caseZEND_USER_FUNCTION:
caseZEND_INTERNAL_FUNCTION:
 {
zend_class_entry*ce=func->common.scope;

if (space) {
*space=ce ? "::" : "";
 }
returnce ? ZSTR_VAL(ce->name) : "";
 }
default:
if (space) {
*space="";
 }
return"";
 }
}
/* }}} */

ZEND_APIconstchar*get_active_function_name(void) /* {{{ */
{
zend_function*func;

if (!zend_is_executing()) {
returnNULL;
 }

func=zend_active_function();

switch (func->type) {
caseZEND_USER_FUNCTION: {
zend_string*function_name=func->common.function_name;

if (function_name) {
returnZSTR_VAL(function_name);
 } else {
return"main";
 }
 }
break;
caseZEND_INTERNAL_FUNCTION:
returnZSTR_VAL(func->common.function_name);
break;
default:
returnNULL;
 }
}
/* }}} */

ZEND_APIzend_function*zend_active_function_ex(zend_execute_data*execute_data)
{
zend_function*func=EX(func);

/* Resolve function if op is a frameless call. */
if (ZEND_USER_CODE(func->type)) {
constzend_op*op=EX(opline);
if (ZEND_OP_IS_FRAMELESS_ICALL(op->opcode)) {
func=ZEND_FLF_FUNC(op);
 }
 }

returnfunc;
}

ZEND_APIzend_string*get_active_function_or_method_name(void) /* {{{ */
{
ZEND_ASSERT(zend_is_executing());

returnget_function_or_method_name(zend_active_function());
}
/* }}} */

ZEND_APIzend_string*get_function_or_method_name(constzend_function*func) /* {{{ */
{
if (func->common.scope&&func->common.function_name) {
returnzend_create_member_string(func->common.scope->name, func->common.function_name);
 }

returnfunc->common.function_name ? zend_string_copy(func->common.function_name) : ZSTR_INIT_LITERAL("main", 0);
}
/* }}} */

ZEND_APIconstchar*get_active_function_arg_name(uint32_targ_num) /* {{{ */
{
if (!zend_is_executing()) {
returnNULL;
 }

zend_function*func=zend_active_function();

returnget_function_arg_name(func, arg_num);
}
/* }}} */

ZEND_APIconstchar*get_function_arg_name(constzend_function*func, uint32_targ_num) /* {{{ */
{
if (!func||arg_num==0||func->common.num_args<arg_num) {
returnNULL;
 }

if (func->type==ZEND_USER_FUNCTION|| (func->common.fn_flags&ZEND_ACC_USER_ARG_INFO)) {
returnZSTR_VAL(func->common.arg_info[arg_num-1].name);
 } else {
return ((zend_internal_arg_info*) func->common.arg_info)[arg_num-1].name;
 }
}
/* }}} */

ZEND_APIconstchar*zend_get_executed_filename(void) /* {{{ */
{
zend_string*filename=zend_get_executed_filename_ex();
returnfilename!=NULL ? ZSTR_VAL(filename) : "[no active file]";
}
/* }}} */

ZEND_APIzend_string*zend_get_executed_filename_ex(void) /* {{{ */
{
zend_string*filename_override=EG(filename_override);
if (filename_override!=NULL) {
returnfilename_override;
 }

zend_execute_data*ex=EG(current_execute_data);

while (ex&& (!ex->func|| !ZEND_USER_CODE(ex->func->type))) {
ex=ex->prev_execute_data;
 }
if (ex) {
returnex->func->op_array.filename;
 } else {
returnNULL;
 }
}
/* }}} */

ZEND_APIuint32_tzend_get_executed_lineno(void) /* {{{ */
{
zend_longlineno_override=EG(lineno_override);
if (lineno_override!=-1) {
returnlineno_override;
 }

zend_execute_data*ex=EG(current_execute_data);

while (ex&& (!ex->func|| !ZEND_USER_CODE(ex->func->type))) {
ex=ex->prev_execute_data;
 }
if (ex) {
if (!ex->opline) {
/* Missing SAVE_OPLINE()? Falling back to first line of function */
returnex->func->op_array.opcodes[0].lineno;
 }
if (EG(exception) &&ex->opline->opcode==ZEND_HANDLE_EXCEPTION&&
ex->opline->lineno==0&&EG(opline_before_exception)) {
returnEG(opline_before_exception)->lineno;
 }
returnex->opline->lineno;
 } else {
return0;
 }
}
/* }}} */

ZEND_APIzend_class_entry*zend_get_executed_scope(void) /* {{{ */
{
zend_execute_data*ex=EG(current_execute_data);

while (1) {
if (!ex) {
returnNULL;
 } elseif (ex->func&& (ZEND_USER_CODE(ex->func->type) ||ex->func->common.scope)) {
returnex->func->common.scope;
 }
ex=ex->prev_execute_data;
 }
}
/* }}} */

ZEND_APIboolzend_is_executing(void) /* {{{ */
{
returnEG(current_execute_data) !=0;
}
/* }}} */

ZEND_APIzend_resultZEND_FASTCALLzval_update_constant_with_ctx(zval*p, zend_class_entry*scope, zend_ast_evaluate_ctx*ctx)
{
if (Z_TYPE_P(p) ==IS_CONSTANT_AST) {
zend_ast*ast=Z_ASTVAL_P(p);

if (ast->kind==ZEND_AST_CONSTANT) {
zend_string*name=zend_ast_get_constant_name(ast);
zval*zv=zend_get_constant_ex(name, scope, ast->attr);
if (UNEXPECTED(zv==NULL)) {
returnFAILURE;
 }

zval_ptr_dtor_nogc(p);
ZVAL_COPY_OR_DUP(p, zv);
 } else {
zvaltmp;
boolshort_circuited;

// Increase the refcount during zend_ast_evaluate to avoid releasing the ast too early
// on nested calls to zval_update_constant_ex which can happen when retriggering ast
// evaluation during autoloading.
zend_ast_ref*ast_ref=Z_AST_P(p);
boolast_is_refcounted= !(GC_FLAGS(ast_ref) &GC_IMMUTABLE);
if (ast_is_refcounted) {
GC_ADDREF(ast_ref);
 }
zend_resultresult=zend_ast_evaluate_ex(&tmp, ast, scope, &short_circuited, ctx) !=SUCCESS;
if (ast_is_refcounted&& !GC_DELREF(ast_ref)) {
rc_dtor_func((zend_refcounted*)ast_ref);
 }
if (UNEXPECTED(result!=SUCCESS)) {
returnFAILURE;
 }
zval_ptr_dtor_nogc(p);
ZVAL_COPY_VALUE(p, &tmp);
 }
 }
returnSUCCESS;
}
/* }}} */

ZEND_APIzend_resultZEND_FASTCALLzval_update_constant_ex(zval*p, zend_class_entry*scope)
{
zend_ast_evaluate_ctxctx= {0};
returnzval_update_constant_with_ctx(p, scope, &ctx);
}

ZEND_APIzend_resultZEND_FASTCALLzval_update_constant(zval*pp) /* {{{ */
{
returnzval_update_constant_ex(pp, EG(current_execute_data) ? zend_get_executed_scope() : CG(active_class_entry));
}
/* }}} */

zend_result_call_user_function_impl(zval*object, zval*function_name, zval*retval_ptr, uint32_tparam_count, zvalparams[], HashTable*named_params) /* {{{ */
{
zend_fcall_infofci;

fci.size=sizeof(fci);
if (object) {
ZEND_ASSERT(Z_TYPE_P(object) ==IS_OBJECT);
fci.object=Z_OBJ_P(object);
 } else {
fci.object=NULL;
 }
ZVAL_COPY_VALUE(&fci.function_name, function_name);
fci.retval=retval_ptr;
fci.param_count=param_count;
fci.params=params;
fci.named_params=named_params;

returnzend_call_function(&fci, NULL);
}
/* }}} */

zend_resultzend_call_function(zend_fcall_info*fci, zend_fcall_info_cache*fci_cache) /* {{{ */
{
uint32_ti;
zend_execute_data*call;
zend_fcall_info_cachefci_cache_local;
zend_function*func;
uint32_tcall_info;
void*object_or_called_scope;
zend_class_entry*orig_fake_scope;

ZVAL_UNDEF(fci->retval);

if (!EG(active)) {
returnFAILURE; /* executor is already inactive */
 }

if (EG(exception)) {
if (fci_cache) {
zend_release_fcall_info_cache(fci_cache);
 }
returnSUCCESS; /* we would result in an unstable executor otherwise */
 }

ZEND_ASSERT(ZEND_FCI_INITIALIZED(*fci));

if (!fci_cache|| !fci_cache->function_handler) {
char*error=NULL;

if (!fci_cache) {
fci_cache=&fci_cache_local;
 }

if (!zend_is_callable_ex(&fci->function_name, fci->object, 0, NULL, fci_cache, &error)) {
ZEND_ASSERT(error&&"Should have error if not callable");
zend_string*callable_name
=zend_get_callable_name_ex(&fci->function_name, fci->object);
zend_throw_error(NULL, "Invalid callback %s, %s", ZSTR_VAL(callable_name), error);
efree(error);
zend_string_release_ex(callable_name, 0);
returnSUCCESS;
 }

ZEND_ASSERT(!error);
 }

func=fci_cache->function_handler;
if ((func->common.fn_flags&ZEND_ACC_STATIC) || !fci_cache->object) {
object_or_called_scope=fci_cache->called_scope;
call_info=ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC;
 } else {
object_or_called_scope=fci_cache->object;
call_info=ZEND_CALL_TOP_FUNCTION | ZEND_CALL_DYNAMIC | ZEND_CALL_HAS_THIS;
 }

call=zend_vm_stack_push_call_frame(call_info,
func, fci->param_count, object_or_called_scope);

if (UNEXPECTED(func->common.fn_flags&ZEND_ACC_DEPRECATED)) {
zend_deprecated_function(func);

if (UNEXPECTED(EG(exception))) {
zend_vm_stack_free_call_frame(call);
returnSUCCESS;
 }
 }

for (i=0; i<fci->param_count; i++) {
zval*param=ZEND_CALL_ARG(call, i+1);
zval*arg=&fci->params[i];
boolmust_wrap=0;
if (UNEXPECTED(Z_ISUNDEF_P(arg))) {
/* Allow forwarding undef slots. This is only used by Closure::__invoke(). */
ZVAL_UNDEF(param);
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_MAY_HAVE_UNDEF);
continue;
 }

if (ARG_SHOULD_BE_SENT_BY_REF(func, i+1)) {
if (UNEXPECTED(!Z_ISREF_P(arg))) {
if (!ARG_MAY_BE_SENT_BY_REF(func, i+1)) {
/* By-value send is not allowed -- emit a warning,
 * and perform the call with the value wrapped in a reference. */
zend_param_must_be_ref(func, i+1);
must_wrap=1;
if (UNEXPECTED(EG(exception))) {
ZEND_CALL_NUM_ARGS(call) =i;
cleanup_args:
zend_vm_stack_free_args(call);
if (ZEND_CALL_INFO(call) &ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
zend_free_extra_named_params(call->extra_named_params);
 }
zend_vm_stack_free_call_frame(call);
zend_release_fcall_info_cache(fci_cache);
returnSUCCESS;
 }
 }
 }
 } else {
if (Z_ISREF_P(arg) &&
 !(func->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
/* don't separate references for __call */
arg=Z_REFVAL_P(arg);
 }
 }

if (EXPECTED(!must_wrap)) {
ZVAL_COPY(param, arg);
 } else {
Z_TRY_ADDREF_P(arg);
ZVAL_NEW_REF(param, arg);
 }
 }

if (fci->named_params) {
zend_string*name;
zval*arg;
uint32_targ_num=ZEND_CALL_NUM_ARGS(call) +1;
boolhave_named_params=0;
ZEND_HASH_FOREACH_STR_KEY_VAL(fci->named_params, name, arg) {
boolmust_wrap=0;
zval*target;
if (name) {
void*cache_slot[2] = {NULL, NULL};
have_named_params=1;
target=zend_handle_named_arg(&call, name, &arg_num, cache_slot);
if (!target) {
 goto cleanup_args;
 }
 } else {
if (have_named_params) {
zend_throw_error(NULL,
"Cannot use positional argument after named argument");
 goto cleanup_args;
 }

zend_vm_stack_extend_call_frame(&call, arg_num-1, 1);
target=ZEND_CALL_ARG(call, arg_num);
 }

if (ARG_SHOULD_BE_SENT_BY_REF(func, arg_num)) {
if (UNEXPECTED(!Z_ISREF_P(arg))) {
if (!ARG_MAY_BE_SENT_BY_REF(func, arg_num)) {
/* By-value send is not allowed -- emit a warning,
 * and perform the call with the value wrapped in a reference. */
zend_param_must_be_ref(func, arg_num);
must_wrap=1;
if (UNEXPECTED(EG(exception))) {
 goto cleanup_args;
 }
 }
 }
 } else {
if (Z_ISREF_P(arg) &&
 !(func->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
/* don't separate references for __call */
arg=Z_REFVAL_P(arg);
 }
 }

if (EXPECTED(!must_wrap)) {
ZVAL_COPY(target, arg);
 } else {
Z_TRY_ADDREF_P(arg);
ZVAL_NEW_REF(target, arg);
 }
if (!name) {
ZEND_CALL_NUM_ARGS(call)++;
arg_num++;
 }
 } ZEND_HASH_FOREACH_END();
 }

if (UNEXPECTED(ZEND_CALL_INFO(call) &ZEND_CALL_MAY_HAVE_UNDEF)) {
/* zend_handle_undef_args assumes prev_execute_data is initialized. */
call->prev_execute_data=NULL;
if (zend_handle_undef_args(call) ==FAILURE) {
zend_vm_stack_free_args(call);
zend_vm_stack_free_call_frame(call);
returnSUCCESS;
 }
 }

if (UNEXPECTED(func->op_array.fn_flags&ZEND_ACC_CLOSURE)) {
uint32_tcall_info;

GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
call_info=ZEND_CALL_CLOSURE;
if (func->common.fn_flags&ZEND_ACC_FAKE_CLOSURE) {
call_info |= ZEND_CALL_FAKE_CLOSURE;
 }
ZEND_ADD_CALL_FLAG(call, call_info);
 }

if (func->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE) {
fci_cache->function_handler=NULL;
 }

orig_fake_scope=EG(fake_scope);