php-src/Zend/zend_execute.c

2675 lines
80 KiB
C
Raw Normal View History

1999-04-08 02:10:10 +08:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
2015-01-15 23:27:30 +08:00
| Copyright (c) 1998-2015 Zend Technologies Ltd. (http://www.zend.com) |
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
2001-12-11 23:16:21 +08:00
| 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: |
2001-12-11 23:16:21 +08:00
| http://www.zend.com/license/2_00.txt. |
1999-07-16 22:58:16 +08:00
| 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. |
1999-04-08 02:10:10 +08:00
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@zend.com> |
| Zeev Suraski <zeev@zend.com> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#define ZEND_INTENSIVE_DEBUGGING 0
1999-07-16 22:58:16 +08:00
1999-04-08 02:10:10 +08:00
#include <stdio.h>
#include <signal.h>
#include "zend.h"
#include "zend_compile.h"
#include "zend_execute.h"
#include "zend_API.h"
#include "zend_ptr_stack.h"
#include "zend_constants.h"
#include "zend_extensions.h"
2002-11-20 01:51:30 +08:00
#include "zend_ini.h"
#include "zend_exceptions.h"
#include "zend_interfaces.h"
#include "zend_closures.h"
#include "zend_generators.h"
#include "zend_vm.h"
2010-04-24 21:32:30 +08:00
#include "zend_dtrace.h"
#include "zend_inheritance.h"
/* Virtual current working directory support */
#include "zend_virtual_cwd.h"
#define _CONST_CODE 0
#define _TMP_CODE 1
#define _VAR_CODE 2
#define _UNUSED_CODE 3
#define _CV_CODE 4
typedef int (ZEND_FASTCALL *incdec_t)(zval *);
1999-04-08 02:10:10 +08:00
2014-12-14 06:06:14 +08:00
#define get_zval_ptr(op_type, node, ex, should_free, type) _get_zval_ptr(op_type, node, ex, should_free, type)
#define get_zval_ptr_deref(op_type, node, ex, should_free, type) _get_zval_ptr_deref(op_type, node, ex, should_free, type)
#define get_zval_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_undef(op_type, node, ex, should_free, type)
2014-12-14 06:06:14 +08:00
#define get_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
#define get_zval_ptr_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
#define get_obj_zval_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr(op_type, node, ex, should_free, type)
#define get_obj_zval_ptr_undef(op_type, node, ex, should_free, type) _get_obj_zval_ptr_undef(op_type, node, ex, should_free, type)
2014-12-14 06:06:14 +08:00
#define get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type)
1999-04-08 02:10:10 +08:00
/* Prototypes */
2014-12-14 06:06:14 +08:00
static void zend_extension_statement_handler(const zend_extension *extension, zend_op_array *op_array);
static void zend_extension_fcall_begin_handler(const zend_extension *extension, zend_op_array *op_array);
static void zend_extension_fcall_end_handler(const zend_extension *extension, zend_op_array *op_array);
1999-04-08 02:10:10 +08:00
#define RETURN_VALUE_USED(opline) (!((opline)->result_type & EXT_TYPE_UNUSED))
1999-12-21 23:55:46 +08:00
static ZEND_FUNCTION(pass)
{
}
static const zend_internal_function zend_pass_function = {
ZEND_INTERNAL_FUNCTION, /* type */
{0, 0, 0}, /* arg_flags */
0, /* fn_flags */
NULL, /* name */
NULL, /* scope */
NULL, /* prototype */
0, /* num_args */
0, /* required_num_args */
NULL, /* arg_info */
ZEND_FN(pass), /* handler */
NULL /* module */
};
#undef zval_ptr_dtor
2014-12-14 06:06:14 +08:00
#define zval_ptr_dtor(zv) i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC)
2014-02-22 00:35:40 +08:00
#define PZVAL_LOCK(z) if (Z_REFCOUNTED_P(z)) Z_ADDREF_P((z))
#define SELECTIVE_PZVAL_LOCK(pzv, opline) if (RETURN_VALUE_USED(opline)) { PZVAL_LOCK(pzv); }
2014-08-27 23:10:29 +08:00
#define READY_TO_DESTROY(zv) \
(zv && Z_REFCOUNTED_P(zv) && Z_REFCOUNT_P(zv) == 1)
#define EXTRACT_ZVAL_PTR(zv) do { \
zval *__zv = (zv); \
if (Z_TYPE_P(__zv) == IS_INDIRECT) { \
ZVAL_COPY(__zv, Z_INDIRECT_P(__zv)); \
} \
} while (0)
2007-12-14 22:14:50 +08:00
#define FREE_OP(should_free) \
if (should_free) { \
zval_ptr_dtor_nogc(should_free); \
}
#define FREE_UNFETCHED_OP(type, var) \
if ((type) & (IS_TMP_VAR|IS_VAR)) { \
zval_ptr_dtor_nogc(EX_VAR(var)); \
}
#define FREE_OP_VAR_PTR(should_free) \
if (should_free) { \
zval_ptr_dtor_nogc(should_free); \
}
/* End of zend_execute_locks.h */
2014-08-08 17:47:34 +08:00
#define CV_DEF_OF(i) (EX(func)->op_array.vars[i])
#define CTOR_CALL_BIT 0x1
#define CTOR_USED_BIT 0x2
#define IS_CTOR_CALL(ce) (((zend_uintptr_t)(ce)) & CTOR_CALL_BIT)
#define IS_CTOR_USED(ce) (((zend_uintptr_t)(ce)) & CTOR_USED_BIT)
#define ENCODE_CTOR(ce, used) \
((zend_class_entry*)(((zend_uintptr_t)(ce)) | CTOR_CALL_BIT | ((used) ? CTOR_USED_BIT : 0)))
#define DECODE_CTOR(ce) \
((zend_class_entry*)(((zend_uintptr_t)(ce)) & ~(CTOR_CALL_BIT|CTOR_USED_BIT)))
#define ZEND_VM_MAIN_STACK_PAGE_SLOTS (16 * 1024) /* should be a power of 2 */
#define ZEND_VM_GENERATOR_STACK_PAGE_SLOTS (256)
#define ZEND_VM_STACK_PAGE_SLOTS(gen) ((gen) ? ZEND_VM_GENERATOR_STACK_PAGE_SLOTS : ZEND_VM_MAIN_STACK_PAGE_SLOTS)
#define ZEND_VM_STACK_PAGE_SIZE(gen) (ZEND_VM_STACK_PAGE_SLOTS(gen) * sizeof(zval))
#define ZEND_VM_STACK_FREE_PAGE_SIZE(gen) \
((ZEND_VM_STACK_PAGE_SLOTS(gen) - ZEND_VM_STACK_HEADER_SLOTS) * sizeof(zval))
#define ZEND_VM_STACK_PAGE_ALIGNED_SIZE(gen, size) \
(((size) + (ZEND_VM_STACK_FREE_PAGE_SIZE(gen) - 1)) & ~(ZEND_VM_STACK_PAGE_SIZE(gen) - 1))
static zend_always_inline zend_vm_stack zend_vm_stack_new_page(size_t size, zend_vm_stack prev) {
zend_vm_stack page = (zend_vm_stack)emalloc(size);
page->top = ZEND_VM_STACK_ELEMETS(page);
page->end = (zval*)((char*)page + size);
page->prev = prev;
return page;
}
2014-12-14 06:06:14 +08:00
ZEND_API void zend_vm_stack_init(void)
{
EG(vm_stack) = zend_vm_stack_new_page(ZEND_VM_STACK_PAGE_SIZE(0 /* main stack */), NULL);
EG(vm_stack)->top++;
EG(vm_stack_top) = EG(vm_stack)->top;
EG(vm_stack_end) = EG(vm_stack)->end;
}
2014-12-14 06:06:14 +08:00
ZEND_API void zend_vm_stack_destroy(void)
{
zend_vm_stack stack = EG(vm_stack);
while (stack != NULL) {
zend_vm_stack p = stack->prev;
efree(stack);
stack = p;
}
}
2014-12-14 06:06:14 +08:00
ZEND_API void* zend_vm_stack_extend(size_t size)
{
zend_vm_stack stack;
void *ptr;
stack = EG(vm_stack);
stack->top = EG(vm_stack_top);
EG(vm_stack) = stack = zend_vm_stack_new_page(
EXPECTED(size < ZEND_VM_STACK_FREE_PAGE_SIZE(0)) ?
ZEND_VM_STACK_PAGE_SIZE(0) : ZEND_VM_STACK_PAGE_ALIGNED_SIZE(0, size),
stack);
ptr = stack->top;
EG(vm_stack_top) = (void*)(((char*)ptr) + size);
EG(vm_stack_end) = stack->end;
return ptr;
}
2014-08-26 01:28:33 +08:00
ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data, uint32_t var)
{
return EX_VAR(var);
}
static zend_always_inline zval *_get_zval_ptr_tmp(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
2005-06-14 01:50:07 +08:00
{
zval *ret = EX_VAR(var);
*should_free = ret;
ZEND_ASSERT(Z_TYPE_P(ret) != IS_REFERENCE);
return ret;
2005-06-14 01:50:07 +08:00
}
static zend_always_inline zval *_get_zval_ptr_var(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
{
zval *ret = EX_VAR(var);
*should_free = ret;
return ret;
}
static zend_always_inline zval *_get_zval_ptr_var_deref(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
{
zval *ret = EX_VAR(var);
*should_free = ret;
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int type, const zend_execute_data *execute_data)
{
zend_string *cv;
switch (type) {
case BP_VAR_R:
case BP_VAR_UNSET:
cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
/* break missing intentionally */
case BP_VAR_IS:
ptr = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
/* break missing intentionally */
case BP_VAR_W:
ZVAL_NULL(ptr);
break;
}
return ptr;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
{
zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
return &EG(uninitialized_zval);
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
{
zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
return &EG(uninitialized_zval);
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
{
zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
ZVAL_NULL(ptr);
zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
return ptr;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
{
ZVAL_NULL(ptr);
return ptr;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv(const zend_execute_data *execute_data, uint32_t var, int type)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup(ret, var, type, execute_data);
}
return ret;
}
static zend_always_inline zval *_get_zval_ptr_cv_undef(const zend_execute_data *execute_data, uint32_t var)
{
return EX_VAR(var);
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref(const zend_execute_data *execute_data, uint32_t var, int type)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup(ret, var, type, execute_data);
}
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_R(ret, var, execute_data);
}
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_R(ret, var, execute_data);
}
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var, execute_data);
}
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var, execute_data);
}
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_RW(ret, var, execute_data);
}
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_RW(ret, var, execute_data);
}
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (Z_TYPE_P(ret) == IS_UNDEF) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_W(ret, var, execute_data);
}
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
2014-04-04 18:36:34 +08:00
{
return EX_VAR(var);
}
static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_RW(const zend_execute_data *execute_data, uint32_t var)
{
return EX_VAR(var);
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(const zend_execute_data *execute_data, uint32_t var)
{
zval *ret = EX_VAR(var);
if (Z_TYPE_P(ret) == IS_UNDEF) {
2014-12-14 06:06:14 +08:00
return _get_zval_cv_lookup_BP_VAR_W(ret, var, execute_data);
}
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(ret);
return ret;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type & (IS_TMP_VAR|IS_VAR)) {
if (op_type == IS_TMP_VAR) {
return _get_zval_ptr_tmp(node.var, execute_data, should_free);
} else {
ZEND_ASSERT(op_type == IS_VAR);
return _get_zval_ptr_var(node.var, execute_data, should_free);
}
2015-01-03 17:22:58 +08:00
} else {
*should_free = NULL;
if (op_type == IS_CONST) {
return EX_CONSTANT(node);
} else if (op_type == IS_CV) {
2014-12-14 06:06:14 +08:00
return _get_zval_ptr_cv(execute_data, node.var, type);
} else {
return NULL;
}
2005-06-14 01:50:07 +08:00
}
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type & (IS_TMP_VAR|IS_VAR)) {
if (op_type == IS_TMP_VAR) {
return _get_zval_ptr_tmp(node.var, execute_data, should_free);
} else {
ZEND_ASSERT(op_type == IS_VAR);
return _get_zval_ptr_var_deref(node.var, execute_data, should_free);
}
2015-01-03 17:22:58 +08:00
} else {
*should_free = NULL;
if (op_type == IS_CONST) {
return EX_CONSTANT(node);
} else if (op_type == IS_CV) {
2014-12-14 06:06:14 +08:00
return _get_zval_ptr_cv_deref(execute_data, node.var, type);
} else {
return NULL;
}
}
}
static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type & (IS_TMP_VAR|IS_VAR)) {
if (op_type == IS_TMP_VAR) {
return _get_zval_ptr_tmp(node.var, execute_data, should_free);
} else {
ZEND_ASSERT(op_type == IS_VAR);
return _get_zval_ptr_var(node.var, execute_data, should_free);
}
} else {
*should_free = NULL;
if (op_type == IS_CONST) {
return EX_CONSTANT(node);
} else if (op_type == IS_CV) {
return _get_zval_ptr_cv_undef(execute_data, node.var);
} else {
return NULL;
}
}
}
static zend_always_inline zval *_get_zval_ptr_ptr_var(uint32_t var, const zend_execute_data *execute_data, zend_free_op *should_free)
{
zval *ret = EX_VAR(var);
2005-06-14 01:50:07 +08:00
if (EXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
*should_free = NULL;
2014-11-17 13:36:14 +08:00
ret = Z_INDIRECT_P(ret);
2015-02-04 22:56:14 +08:00
} else if (!Z_REFCOUNTED_P(ret)) {
*should_free = ret; /* immutable array may be converted to regular */
} else if (Z_REFCOUNT_P(ret) == 1) {
*should_free = ret;
2015-02-04 22:56:14 +08:00
} else {
*should_free = NULL;
Z_DELREF_P(ret);
}
2014-11-17 13:36:14 +08:00
return ret;
}
2014-12-14 06:06:14 +08:00
static inline zval *_get_zval_ptr_ptr(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type == IS_CV) {
*should_free = NULL;
2014-12-14 06:06:14 +08:00
return _get_zval_ptr_cv(execute_data, node.var, type);
} else /* if (op_type == IS_VAR) */ {
ZEND_ASSERT(op_type == IS_VAR);
return _get_zval_ptr_ptr_var(node.var, execute_data, should_free);
}
}
static zend_always_inline zval *_get_obj_zval_ptr_unused(zend_execute_data *execute_data)
{
return &EX(This);
}
2014-12-14 06:06:14 +08:00
static inline zval *_get_obj_zval_ptr(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
2005-06-14 01:50:07 +08:00
{
if (op_type == IS_UNUSED) {
*should_free = NULL;
return &EX(This);
2005-06-14 01:50:07 +08:00
}
return get_zval_ptr(op_type, op, execute_data, should_free, type);
2005-06-14 01:50:07 +08:00
}
static inline zval *_get_obj_zval_ptr_undef(int op_type, znode_op op, zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type == IS_UNUSED) {
*should_free = NULL;
return &EX(This);
}
return get_zval_ptr_undef(op_type, op, execute_data, should_free, type);
}
2014-12-14 06:06:14 +08:00
static inline zval *_get_obj_zval_ptr_ptr(int op_type, znode_op node, zend_execute_data *execute_data, zend_free_op *should_free, int type)
{
if (op_type == IS_UNUSED) {
*should_free = NULL;
return &EX(This);
}
return get_zval_ptr_ptr(op_type, node, execute_data, should_free, type);
}
2014-12-14 06:06:14 +08:00
static inline void zend_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr)
{
zend_reference *ref;
2015-04-29 04:57:21 +08:00
if (EXPECTED(!Z_ISREF_P(value_ptr))) {
ZVAL_NEW_REF(value_ptr, value_ptr);
} else if (UNEXPECTED(variable_ptr == value_ptr)) {
return;
2015-04-29 04:57:21 +08:00
}
ref = Z_REF_P(value_ptr);
GC_REFCOUNT(ref)++;
zval_ptr_dtor(variable_ptr);
ZVAL_REF(variable_ptr, ref);
}
/* this should modify object only if it's empty */
2015-02-26 04:20:47 +08:00
static inline int make_real_object(zval *object)
2002-03-11 05:02:00 +08:00
{
2014-04-04 06:52:53 +08:00
if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
2015-02-26 04:20:47 +08:00
if (EXPECTED(Z_TYPE_P(object) <= IS_FALSE)) {
/* nothing to destroy */
} else if (EXPECTED((Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0))) {
zval_ptr_dtor_nogc(object);
2014-12-09 17:17:55 +08:00
} else {
return 0;
2014-03-14 02:56:18 +08:00
}
2015-02-26 04:20:47 +08:00
object_init(object);
zend_error(E_WARNING, "Creating default object from empty value");
}
2014-12-09 17:17:55 +08:00
return 1;
}
2014-12-14 06:06:14 +08:00
ZEND_API char * zend_verify_internal_arg_class_kind(const zend_internal_arg_info *cur_arg_info, char **class_name, zend_class_entry **pce)
{
zend_string *key;
ALLOCA_FLAG(use_heap);
ZSTR_ALLOCA_INIT(key, cur_arg_info->class_name, strlen(cur_arg_info->class_name), use_heap);
2014-12-14 06:06:14 +08:00
*pce = zend_fetch_class(key, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD));
ZSTR_ALLOCA_FREE(key, use_heap);
*class_name = (*pce) ? ZSTR_VAL((*pce)->name) : (char*)cur_arg_info->class_name;
if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) {
return "implement interface ";
} else {
return "be an instance of ";
}
}
static zend_always_inline zend_class_entry* zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info)
{
return zend_fetch_class(cur_arg_info->class_name, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD));
}
ZEND_API void zend_verify_arg_error(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)
{
zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
const char *fname = ZSTR_VAL(zf->common.function_name);
const char *fsep;
const char *fclass;
if (zf->common.scope) {
fsep = "::";
fclass = ZSTR_VAL(zf->common.scope->name);
} else {
fsep = "";
fclass = "";
}
2014-11-27 17:52:31 +08:00
if (zf->common.type == ZEND_USER_FUNCTION) {
if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) {
2015-03-20 16:10:29 +08:00
zend_type_error("Argument %d passed to %s%s%s() must %s%s, %s%s given, called in %s on line %d",
arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind,
ZSTR_VAL(ptr->func->op_array.filename), ptr->opline->lineno);
2014-11-27 17:52:31 +08:00
} else {
zend_type_error("Argument %d passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
2014-11-27 17:52:31 +08:00
}
} else {
zend_type_error("Argument %d passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
}
}
2014-12-14 06:06:14 +08:00
static int is_null_constant(zval *default_value)
2014-11-25 23:09:08 +08:00
{
if (Z_CONSTANT_P(default_value)) {
zval constant;
2014-11-25 23:09:08 +08:00
ZVAL_COPY_VALUE(&constant, default_value);
if (UNEXPECTED(zval_update_constant_ex(&constant, 0, NULL) != SUCCESS)) {
return 0;
}
2014-11-25 23:09:08 +08:00
if (Z_TYPE(constant) == IS_NULL) {
return 1;
}
zval_dtor(&constant);
}
return 0;
}
static zend_bool zend_verify_weak_scalar_type_hint(zend_uchar type_hint, zval *arg)
{
switch (type_hint) {
case _IS_BOOL: {
zend_bool dest;
if (!zend_parse_arg_bool_weak(arg, &dest)) {
return 0;
}
zval_ptr_dtor(arg);
ZVAL_BOOL(arg, dest);
return 1;
}
case IS_LONG: {
zend_long dest;
if (!zend_parse_arg_long_weak(arg, &dest)) {
return 0;
}
zval_ptr_dtor(arg);
ZVAL_LONG(arg, dest);
return 1;
}
case IS_DOUBLE: {
double dest;
if (!zend_parse_arg_double_weak(arg, &dest)) {
return 0;
}
zval_ptr_dtor(arg);
ZVAL_DOUBLE(arg, dest);
return 1;
}
case IS_STRING: {
zend_string *dest;
/* on success "arg" is converted to IS_STRING */
if (!zend_parse_arg_str_weak(arg, &dest)) {
return 0;
}
return 1;
}
default:
return 0;
}
}
static zend_bool zend_verify_scalar_type_hint(zend_uchar type_hint, zval *arg, zend_bool strict)
{
if (UNEXPECTED(strict)) {
/* SSTH Exception: IS_LONG may be accepted as IS_DOUBLE (converted) */
if (type_hint != IS_DOUBLE || Z_TYPE_P(arg) != IS_LONG) {
return 0;
}
} else if (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
2015-03-20 22:26:38 +08:00
/* NULL may be accepted only by nullable hints (this is already checked) */
return 0;
}
return zend_verify_weak_scalar_type_hint(type_hint, arg);
}
static void zend_verify_internal_arg_type(zend_function *zf, uint32_t arg_num, zval *arg)
{
zend_internal_arg_info *cur_arg_info;
char *need_msg, *class_name;
zend_class_entry *ce;
if (EXPECTED(arg_num <= zf->internal_function.num_args)) {
cur_arg_info = &zf->internal_function.arg_info[arg_num-1];
} else if (zf->internal_function.fn_flags & ZEND_ACC_VARIADIC) {
cur_arg_info = &zf->internal_function.arg_info[zf->internal_function.num_args];
} else {
return;
}
if (cur_arg_info->type_hint) {
ZVAL_DEREF(arg);
if (EXPECTED(cur_arg_info->type_hint == Z_TYPE_P(arg))) {
if (cur_arg_info->class_name) {
need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info*)cur_arg_info, &class_name, &ce);
if (!ce || !instanceof_function(Z_OBJCE_P(arg), ce)) {
zend_verify_arg_error(zf, arg_num, need_msg, class_name, "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg);
}
}
} else if (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null) {
if (cur_arg_info->class_name) {
need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info*)cur_arg_info, &class_name, &ce);
zend_verify_arg_error(zf, arg_num, need_msg, class_name, zend_zval_type_name(arg), "", arg);
} else if (cur_arg_info->type_hint == IS_CALLABLE) {
if (!zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL)) {
zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), "", arg);
}
} else if (cur_arg_info->type_hint == _IS_BOOL &&
EXPECTED(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE)) {
/* pass */
} else if (UNEXPECTED(!zend_verify_scalar_type_hint(cur_arg_info->type_hint, arg, ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data))))) {
zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), "", arg);
}
}
}
}
static zend_always_inline int zend_verify_arg_type(zend_function *zf, uint32_t arg_num, zval *arg, zval *default_value, void **cache_slot)
{
zend_arg_info *cur_arg_info;
char *need_msg;
2006-05-22 02:10:31 +08:00
zend_class_entry *ce;
2014-04-04 18:36:34 +08:00
if (EXPECTED(arg_num <= zf->common.num_args)) {
cur_arg_info = &zf->common.arg_info[arg_num-1];
} else if (UNEXPECTED(zf->common.fn_flags & ZEND_ACC_VARIADIC)) {
cur_arg_info = &zf->common.arg_info[zf->common.num_args];
} else {
2015-04-29 04:57:21 +08:00
return 1;
}
if (cur_arg_info->type_hint) {
2014-03-27 17:39:09 +08:00
ZVAL_DEREF(arg);
if (EXPECTED(cur_arg_info->type_hint == Z_TYPE_P(arg))) {
if (cur_arg_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(cur_arg_info);
if (UNEXPECTED(!ce)) {
zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg);
return 0;
}
*cache_slot = (void*)ce;
}
if (UNEXPECTED(!instanceof_function(Z_OBJCE_P(arg), ce))) {
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg);
2015-04-29 04:57:21 +08:00
return 0;
}
2006-05-22 02:10:31 +08:00
}
2014-12-14 06:06:14 +08:00
} else if (Z_TYPE_P(arg) != IS_NULL || !(cur_arg_info->allow_null || (default_value && is_null_constant(default_value)))) {
if (cur_arg_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(cur_arg_info);
if (UNEXPECTED(!ce)) {
if (Z_TYPE_P(arg) == IS_OBJECT) {
zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(arg)->name), arg);
} else {
zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "", zend_zval_type_name(arg), arg);
}
return 0;
}
*cache_slot = (void*)ce;
}
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), zend_zval_type_name(arg), "", arg);
2015-04-29 04:57:21 +08:00
return 0;
} else if (cur_arg_info->type_hint == IS_CALLABLE) {
if (!zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL)) {
zend_verify_arg_error(zf, arg_num, "be callable", "", zend_zval_type_name(arg), "", arg);
2015-04-29 04:57:21 +08:00
return 0;
}
} else if (cur_arg_info->type_hint == _IS_BOOL &&
EXPECTED(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE)) {
/* pass */
} else if (UNEXPECTED(!zend_verify_scalar_type_hint(cur_arg_info->type_hint, arg, ZEND_ARG_USES_STRICT_TYPES()))) {
zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), zend_zval_type_name(arg), "", arg);
2015-04-29 04:57:21 +08:00
return 0;
2014-06-05 22:42:17 +08:00
}
2010-05-21 03:18:35 +08:00
}
}
2015-04-29 04:57:21 +08:00
return 1;
2014-04-04 18:36:34 +08:00
}
static zend_always_inline int zend_verify_missing_arg_type(zend_function *zf, uint32_t arg_num, void **cache_slot)
2014-04-04 18:36:34 +08:00
{
zend_arg_info *cur_arg_info;
char *need_msg;
zend_class_entry *ce;
if (EXPECTED(arg_num <= zf->common.num_args)) {
cur_arg_info = &zf->common.arg_info[arg_num-1];
} else if (UNEXPECTED(zf->common.fn_flags & ZEND_ACC_VARIADIC)) {
cur_arg_info = &zf->common.arg_info[zf->common.num_args];
2014-04-04 18:36:34 +08:00
} else {
return 1;
}
if (cur_arg_info->type_hint) {
if (cur_arg_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(cur_arg_info);
if (UNEXPECTED(!ce)) {
zend_verify_arg_error(zf, arg_num, "be an instance of ", ZSTR_VAL(cur_arg_info->class_name), "none", "", NULL);
return 0;
}
*cache_slot = (void*)ce;
}
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_arg_error(zf, arg_num, need_msg, ZSTR_VAL(ce->name), "none", "", NULL);
2014-06-05 22:42:17 +08:00
} else if (cur_arg_info->type_hint == IS_CALLABLE) {
zend_verify_arg_error(zf, arg_num, "be callable", "", "none", "", NULL);
2014-06-05 22:42:17 +08:00
} else {
zend_verify_arg_error(zf, arg_num, "be of the type ", zend_get_type_by_const(cur_arg_info->type_hint), "none", "", NULL);
2014-04-04 18:36:34 +08:00
}
2014-09-10 17:02:01 +08:00
return 0;
2014-04-04 18:36:34 +08:00
}
2014-09-10 17:02:01 +08:00
return 1;
2014-04-04 18:36:34 +08:00
}
static zend_always_inline int zend_verify_missing_arg(zend_execute_data *execute_data, uint32_t arg_num, void **cache_slot)
2014-04-04 18:36:34 +08:00
{
if (EXPECTED(!(EX(func)->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS)) ||
zend_verify_missing_arg_type(EX(func), arg_num, cache_slot)) {
const char *class_name = EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->name) : "";
const char *space = EX(func)->common.scope ? "::" : "";
const char *func_name = EX(func)->common.function_name ? ZSTR_VAL(EX(func)->common.function_name) : "main";
2014-04-04 18:36:34 +08:00
zend_execute_data *ptr = EX(prev_execute_data);
if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) {
zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", arg_num, class_name, space, func_name, ZSTR_VAL(ptr->func->op_array.filename), ptr->opline->lineno);
2014-04-04 18:36:34 +08:00
} else {
zend_error(E_WARNING, "Missing argument %u for %s%s%s()", arg_num, class_name, space, func_name);
}
2015-04-29 04:57:21 +08:00
return 1;
2014-04-04 18:36:34 +08:00
}
2015-04-29 04:57:21 +08:00
return 0;
}
ZEND_API void zend_verify_return_error(const zend_function *zf, const char *need_msg, const char *need_kind, const char *returned_msg, const char *returned_kind)
{
const char *fname = ZSTR_VAL(zf->common.function_name);
const char *fsep;
const char *fclass;
if (zf->common.scope) {
fsep = "::";
fclass = ZSTR_VAL(zf->common.scope->name);
} else {
fsep = "";
fclass = "";
}
if (zf->common.type == ZEND_USER_FUNCTION) {
zend_type_error("Return value of %s%s%s() must %s%s, %s%s returned in %s on line %d",
fclass, fsep, fname, need_msg, need_kind, returned_msg, returned_kind,
ZSTR_VAL(zf->op_array.filename), EG(current_execute_data)->opline->lineno);
} else {
zend_type_error("Return value of %s%s%s() must %s%s, %s%s returned",
fclass, fsep, fname, need_msg, need_kind, returned_msg, returned_kind);
}
}
ZEND_API void zend_verify_internal_return_error(const zend_function *zf, const char *need_msg, const char *need_kind, const char *returned_msg, const char *returned_kind)
{
const char *fname = ZSTR_VAL(zf->common.function_name);
const char *fsep;
const char *fclass;
if (zf->common.scope) {
fsep = "::";
fclass = ZSTR_VAL(zf->common.scope->name);
} else {
fsep = "";
fclass = "";
}
zend_error_noreturn(E_CORE_ERROR, "Return value of %s%s%s() must %s%s, %s%s returned",
fclass, fsep, fname, need_msg, need_kind, returned_msg, returned_kind);
}
#if ZEND_DEBUG
static int zend_verify_internal_return_type(zend_function *zf, zval *ret)
{
zend_arg_info *ret_info = zf->common.arg_info - 1;
char *need_msg, *class_name;
zend_class_entry *ce;
if (ret_info->type_hint) {
if (EXPECTED(ret_info->type_hint == Z_TYPE_P(ret))) {
if (ret_info->class_name) {
need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info *)ret_info, &class_name, &ce);
if (!ce || !instanceof_function(Z_OBJCE_P(ret), ce)) {
zend_verify_internal_return_error(zf, need_msg, class_name, "instance of ", ZSTR_VAL(Z_OBJCE_P(ret)->name));
return 0;
}
}
} else if (Z_TYPE_P(ret) != IS_NULL || !ret_info->allow_null) {
if (ret_info->class_name) {
need_msg = zend_verify_internal_arg_class_kind((zend_internal_arg_info *)ret_info, &class_name, &ce);
zend_verify_internal_return_error(zf, need_msg, class_name, zend_zval_type_name(ret), "");
} else if (ret_info->type_hint == IS_CALLABLE) {
if (!zend_is_callable(ret, IS_CALLABLE_CHECK_SILENT, NULL) && (Z_TYPE_P(ret) != IS_NULL || !ret_info->allow_null)) {
zend_verify_internal_return_error(zf, "be callable", "", zend_zval_type_name(ret), "");
return 0;
}
} else if (ret_info->type_hint == _IS_BOOL &&
EXPECTED(Z_TYPE_P(ret) == IS_FALSE || Z_TYPE_P(ret) == IS_TRUE)) {
/* pass */
} else {
/* Use strict check to verify return value of internal function */
zend_verify_internal_return_error(zf, "be of the type ", zend_get_type_by_const(ret_info->type_hint), zend_zval_type_name(ret), "");
return 0;
}
}
}
return 1;
}
#endif
static zend_always_inline void zend_verify_return_type(zend_function *zf, zval *ret, void **cache_slot)
{
zend_arg_info *ret_info = zf->common.arg_info - 1;
char *need_msg;
zend_class_entry *ce;
if (ret_info->type_hint) {
if (EXPECTED(ret_info->type_hint == Z_TYPE_P(ret))) {
if (ret_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(ret_info);
if (UNEXPECTED(!ce)) {
zend_verify_return_error(zf, "be an instance of ", ZSTR_VAL(ret_info->class_name), "instance of ", ZSTR_VAL(Z_OBJCE_P(ret)->name));
return;
}
*cache_slot = (void*)ce;
}
if (UNEXPECTED(!instanceof_function(Z_OBJCE_P(ret), ce))) {
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_return_error(zf, need_msg, ZSTR_VAL(ce->name), "instance of ", ZSTR_VAL(Z_OBJCE_P(ret)->name));
}
}
} else if (Z_TYPE_P(ret) != IS_NULL || !ret_info->allow_null) {
if (ret_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(ret_info);
if (UNEXPECTED(!ce)) {
zend_verify_return_error(zf, "be an instance of ", ZSTR_VAL(ret_info->class_name), zend_zval_type_name(ret), "");
return;
}
*cache_slot = (void*)ce;
}
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_return_error(zf, need_msg, ZSTR_VAL(ce->name), zend_zval_type_name(ret), "");
} else if (ret_info->type_hint == IS_CALLABLE) {
if (!zend_is_callable(ret, IS_CALLABLE_CHECK_SILENT, NULL)) {
zend_verify_return_error(zf, "be callable", "", zend_zval_type_name(ret), "");
}
} else if (ret_info->type_hint == _IS_BOOL &&
EXPECTED(Z_TYPE_P(ret) == IS_FALSE || Z_TYPE_P(ret) == IS_TRUE)) {
/* pass */
} else if (UNEXPECTED(!zend_verify_scalar_type_hint(ret_info->type_hint, ret, ZEND_RET_USES_STRICT_TYPES()))) {
zend_verify_return_error(zf, "be of the type ", zend_get_type_by_const(ret_info->type_hint), zend_zval_type_name(ret), "");
}
}
}
}
static zend_always_inline int zend_verify_missing_return_type(zend_function *zf, void **cache_slot)
{
zend_arg_info *ret_info = zf->common.arg_info - 1;
char *need_msg;
zend_class_entry *ce;
if (ret_info->type_hint) {
if (ret_info->class_name) {
if (EXPECTED(*cache_slot)) {
ce = (zend_class_entry*)*cache_slot;
} else {
ce = zend_verify_arg_class_kind(ret_info);
if (UNEXPECTED(!ce)) {
zend_verify_return_error(zf, "be an instance of ", ZSTR_VAL(ret_info->class_name), "none", "");
return 0;
}
*cache_slot = (void*)ce;
}
need_msg =
(ce->ce_flags & ZEND_ACC_INTERFACE) ?
"implement interface " : "be an instance of ";
zend_verify_return_error(zf, need_msg, ZSTR_VAL(ce->name), "none", "");
return 0;
} else if (ret_info->type_hint == IS_CALLABLE) {
zend_verify_return_error(zf, "be callable", "", "none", "");
} else {
zend_verify_return_error(zf, "be of the type ", zend_get_type_by_const(ret_info->type_hint), "none", "");
}
return 0;
}
return 1;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline void zend_assign_to_object(zval *retval, zval *object, uint32_t object_op_type, zval *property_name, uint32_t property_op_type, int value_type, znode_op value_op, const zend_execute_data *execute_data, void **cache_slot)
{
2007-12-14 22:14:50 +08:00
zend_free_op free_value;
2015-04-03 06:32:20 +08:00
zval *value = get_zval_ptr(value_type, value_op, execute_data, &free_value, BP_VAR_R);
zval tmp;
2014-12-09 05:10:23 +08:00
if (object_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
do {
if (object_op_type == IS_VAR && UNEXPECTED(object == &EG(error_zval))) {
2014-12-09 05:10:23 +08:00
if (retval) {
ZVAL_NULL(retval);
}
FREE_OP(free_value);
return;
2007-12-14 22:14:50 +08:00
}
if (Z_ISREF_P(object)) {
object = Z_REFVAL_P(object);
if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
break;
}
}
2014-12-09 05:10:23 +08:00
if (EXPECTED(Z_TYPE_P(object) <= IS_FALSE ||
(Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0))) {
zend_object *obj;
zval_ptr_dtor(object);
object_init(object);
Z_ADDREF_P(object);
obj = Z_OBJ_P(object);
zend_error(E_WARNING, "Creating default object from empty value");
if (GC_REFCOUNT(obj) == 1) {
/* the enclosing container was deleted, obj is unreferenced */
if (retval) {
ZVAL_NULL(retval);
}
FREE_OP(free_value);
OBJ_RELEASE(obj);
return;
}
Z_DELREF_P(object);
} else {
zend_error(E_WARNING, "Attempt to assign property of non-object");
2014-07-29 18:34:43 +08:00
if (retval) {
ZVAL_NULL(retval);
}
2014-07-29 18:34:43 +08:00
FREE_OP(free_value);
return;
2014-04-15 19:40:40 +08:00
}
2014-12-09 05:10:23 +08:00
} while (0);
}
2014-12-09 05:10:23 +08:00
if (property_op_type == IS_CONST &&
EXPECTED(Z_OBJCE_P(object) == CACHED_PTR_EX(cache_slot))) {
uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
2014-12-09 05:10:23 +08:00
zend_object *zobj = Z_OBJ_P(object);
zval *property;
2014-11-25 04:19:24 +08:00
2015-02-26 04:20:47 +08:00
if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
property = OBJ_PROP(zobj, prop_offset);
2014-12-09 05:10:23 +08:00
if (Z_TYPE_P(property) != IS_UNDEF) {
2014-11-25 04:19:24 +08:00
fast_assign:
2014-12-14 06:06:14 +08:00
value = zend_assign_to_variable(property, value, value_type);
2015-04-15 18:34:23 +08:00
if (retval && EXPECTED(!EG(exception))) {
2014-12-09 05:10:23 +08:00
ZVAL_COPY(retval, value);
2014-11-25 04:19:24 +08:00
}
2014-12-09 05:10:23 +08:00
return;
}
} else {
if (EXPECTED(zobj->properties != NULL)) {
property = zend_hash_find(zobj->properties, Z_STR_P(property_name));
if (property) {
goto fast_assign;
}
}
2014-11-25 04:19:24 +08:00
2014-12-09 05:10:23 +08:00
if (!zobj->ce->__set) {
2015-04-15 18:34:23 +08:00
2014-12-09 05:10:23 +08:00
if (EXPECTED(zobj->properties == NULL)) {
2015-01-03 17:22:58 +08:00
rebuild_object_properties(zobj);
2014-12-09 05:10:23 +08:00
}
/* separate our value if necessary */
if (value_type == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
ZVAL_COPY_VALUE(&tmp, value);
zval_copy_ctor_func(&tmp);
value = &tmp;
2014-11-25 04:19:24 +08:00
}
2015-04-03 06:32:20 +08:00
} else if (value_type != IS_TMP_VAR) {
2015-04-15 18:34:23 +08:00
if (Z_ISREF_P(value)) {
2015-04-20 23:49:17 +08:00
if (value_type == IS_VAR) {
zend_reference *ref = Z_REF_P(value);
if (--(GC_REFCOUNT(ref)) == 0) {
ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
efree_size(ref, sizeof(zend_reference));
value = &tmp;
} else {
value = Z_REFVAL_P(value);
if (Z_REFCOUNTED_P(value)) {
Z_ADDREF_P(value);
}
}
} else {
value = Z_REFVAL_P(value);
if (Z_REFCOUNTED_P(value)) {
Z_ADDREF_P(value);
}
2015-04-15 18:34:23 +08:00
}
} else if (value_type == IS_CV && Z_REFCOUNTED_P(value)) {
2015-04-03 06:32:20 +08:00
Z_ADDREF_P(value);
}
2014-11-25 04:19:24 +08:00
}
2014-12-09 05:10:23 +08:00
zend_hash_add_new(zobj->properties, Z_STR_P(property_name), value);
2015-04-15 18:34:23 +08:00
if (retval) {
2014-12-09 05:10:23 +08:00
ZVAL_COPY(retval, value);
}
return;
2014-11-25 04:19:24 +08:00
}
2014-12-09 05:10:23 +08:00
}
}
2014-11-25 04:19:24 +08:00
2014-12-09 05:10:23 +08:00
if (!Z_OBJ_HT_P(object)->write_property) {
zend_error(E_WARNING, "Attempt to assign property of non-object");
if (retval) {
ZVAL_NULL(retval);
}
2014-12-09 05:10:23 +08:00
FREE_OP(free_value);
return;
}
2014-11-25 04:19:24 +08:00
2014-12-09 05:10:23 +08:00
/* separate our value if necessary */
if (value_type == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
ZVAL_COPY_VALUE(&tmp, value);
zval_copy_ctor_func(&tmp);
value = &tmp;
2014-11-25 04:19:24 +08:00
}
2015-04-03 06:32:20 +08:00
} else if (value_type != IS_TMP_VAR) {
ZVAL_DEREF(value);
2014-12-09 05:10:23 +08:00
}
2014-12-14 06:06:14 +08:00
Z_OBJ_HT_P(object)->write_property(object, property_name, value, cache_slot);
2014-12-09 05:10:23 +08:00
2015-04-15 18:34:23 +08:00
if (retval && EXPECTED(!EG(exception))) {
2014-12-09 05:10:23 +08:00
ZVAL_COPY(retval, value);
}
2015-04-15 18:34:23 +08:00
if (value_type == IS_CONST) {
zval_ptr_dtor_nogc(value);
} else {
2014-12-09 05:10:23 +08:00
FREE_OP(free_value);
}
}
static zend_never_inline void zend_assign_to_object_dim(zval *retval, zval *object, zval *property_name, int value_type, znode_op value_op, const zend_execute_data *execute_data)
2014-12-09 05:10:23 +08:00
{
zend_free_op free_value;
zval *value = get_zval_ptr_deref(value_type, value_op, execute_data, &free_value, BP_VAR_R);
zval tmp;
/* Note: property_name in this case is really the array index! */
if (!Z_OBJ_HT_P(object)->write_dimension) {
2015-07-04 05:04:33 +08:00
zend_throw_error(zend_ce_error, "Cannot use object as array");
FREE_OP(free_value);
return;
2014-12-09 05:10:23 +08:00
}
2014-11-25 04:19:24 +08:00
2014-12-09 05:10:23 +08:00
/* separate our value if necessary */
if (value_type == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
ZVAL_COPY_VALUE(&tmp, value);
zval_copy_ctor_func(&tmp);
value = &tmp;
}
}
2014-12-14 06:06:14 +08:00
Z_OBJ_HT_P(object)->write_dimension(object, property_name, value);
2014-12-09 05:10:23 +08:00
2015-04-15 18:34:23 +08:00
if (retval && EXPECTED(!EG(exception))) {
ZVAL_COPY(retval, value);
}
2015-04-15 18:34:23 +08:00
if (value_type == IS_CONST) {
zval_ptr_dtor_nogc(value);
} else {
FREE_OP(free_value);
}
}
static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *property, zval *value, zval *retval, binary_op_type binary_op)
{
zval *z;
zval rv, res;
if (Z_OBJ_HT_P(object)->read_dimension &&
2014-12-14 06:06:14 +08:00
(z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv)) != NULL) {
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval rv2;
zval *value = Z_OBJ_HT_P(z)->get(z, &rv2);
if (z == &rv) {
zval_ptr_dtor(&rv);
}
ZVAL_COPY_VALUE(z, value);
}
binary_op(&res, Z_ISREF_P(z) ? Z_REFVAL_P(z) : z, value);
Z_OBJ_HT_P(object)->write_dimension(object, property, &res);
if (z == &rv) {
zval_ptr_dtor(&rv);
}
if (retval) {
ZVAL_COPY(retval, &res);
}
zval_ptr_dtor(&res);
} else {
zend_error(E_WARNING, "Attempt to assign property of non-object");
if (retval) {
ZVAL_NULL(retval);
}
}
}
2014-12-14 06:06:14 +08:00
static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *value, zval *result)
2014-09-07 06:54:47 +08:00
{
2014-04-04 06:52:53 +08:00
zend_string *old_str;
1999-04-08 02:10:10 +08:00
2014-09-07 06:54:47 +08:00
if (offset < 0) {
zend_error(E_WARNING, "Illegal string offset: " ZEND_LONG_FMT, offset);
2014-08-26 01:24:55 +08:00
zend_string_release(Z_STR_P(str));
2014-04-04 06:52:53 +08:00
if (result) {
ZVAL_NULL(result);
}
return;
}
2014-04-04 06:52:53 +08:00
old_str = Z_STR_P(str);
if ((size_t)offset >= Z_STRLEN_P(str)) {
2014-09-07 06:54:47 +08:00
zend_long old_len = Z_STRLEN_P(str);
Z_STR_P(str) = zend_string_extend(Z_STR_P(str), offset + 1, 0);
Z_TYPE_INFO_P(str) = IS_STRING_EX;
2014-02-28 21:39:08 +08:00
memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len);
Z_STRVAL_P(str)[offset+1] = 0;
} else if (!Z_REFCOUNTED_P(str)) {
2014-08-26 01:24:55 +08:00
Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
Z_TYPE_INFO_P(str) = IS_STRING_EX;
}
1999-04-08 02:10:10 +08:00
if (Z_TYPE_P(value) != IS_STRING) {
zend_string *tmp = zval_get_string(value);
Z_STRVAL_P(str)[offset] = ZSTR_VAL(tmp)[0];
2014-08-26 01:24:55 +08:00
zend_string_release(tmp);
} else {
2014-02-28 21:39:08 +08:00
Z_STRVAL_P(str)[offset] = Z_STRVAL_P(value)[0];
1999-04-08 02:10:10 +08:00
}
/*
* the value of an assignment to a string offset is undefined
T(result->u.var).var = &T->str_offset.str;
*/
2014-04-04 06:52:53 +08:00
2014-08-26 01:24:55 +08:00
zend_string_release(old_str);
2014-04-04 06:52:53 +08:00
if (result) {
zend_uchar c = (zend_uchar)Z_STRVAL_P(str)[offset];
if (CG(one_char_string)[c]) {
2014-08-26 01:28:33 +08:00
ZVAL_INTERNED_STR(result, CG(one_char_string)[c]);
2014-04-04 06:52:53 +08:00
} else {
2014-08-26 01:24:55 +08:00
ZVAL_NEW_STR(result, zend_string_init(Z_STRVAL_P(str) + offset, 1, 0));
2014-04-04 06:52:53 +08:00
}
}
2007-12-14 22:14:50 +08:00
}
1999-04-08 02:10:10 +08:00
static zend_never_inline void zend_post_incdec_overloaded_property(zval *object, zval *property, void **cache_slot, int inc, zval *result)
{
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
zval rv, obj;
zval *z;
zval z_copy;
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, cache_slot, &rv);
if (UNEXPECTED(EG(exception))) {
OBJ_RELEASE(Z_OBJ(obj));
return;
}
if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
zval rv2;
zval *value = Z_OBJ_HT_P(z)->get(z, &rv2);
if (z == &rv) {
zval_ptr_dtor(&rv);
}
ZVAL_COPY_VALUE(z, value);
}
ZVAL_COPY(result, z);
ZVAL_DUP(&z_copy, z);
if (inc) {
increment_function(&z_copy);
} else {
decrement_function(&z_copy);
}
if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, cache_slot);
OBJ_RELEASE(Z_OBJ(obj));
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(z);
} else {
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
ZVAL_NULL(result);
}
}
static zend_never_inline void zend_pre_incdec_overloaded_property(zval *object, zval *property, void **cache_slot, int inc, zval *result)
{
zval rv;
if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
zval *z, obj;
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, cache_slot, &rv);
if (UNEXPECTED(EG(exception))) {
OBJ_RELEASE(Z_OBJ(obj));
return;
}
if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
zval rv2;
zval *value = Z_OBJ_HT_P(z)->get(z, &rv2);
if (z == &rv) {
zval_ptr_dtor(&rv);
}
ZVAL_COPY_VALUE(z, value);
}
ZVAL_DEREF(z);
SEPARATE_ZVAL_NOREF(z);
if (inc) {
increment_function(z);
} else {
decrement_function(z);
}
if (UNEXPECTED(result)) {
ZVAL_COPY(result, z);
}
Z_OBJ_HT(obj)->write_property(&obj, property, z, cache_slot);
OBJ_RELEASE(Z_OBJ(obj));
zval_ptr_dtor(z);
} else {
zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
if (UNEXPECTED(result)) {
ZVAL_NULL(result);
}
}
}
static zend_never_inline void zend_assign_op_overloaded_property(zval *object, zval *property, void **cache_slot, zval *value, binary_op_type binary_op, zval *result)
{
zval *z;
zval rv, obj;
zval *zptr;
ZVAL_OBJ(&obj, Z_OBJ_P(object));
Z_ADDREF(obj);
if (Z_OBJ_HT(obj)->read_property &&
(z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, cache_slot, &rv)) != NULL) {
if (UNEXPECTED(EG(exception))) {
OBJ_RELEASE(Z_OBJ(obj));
return;
}
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval rv2;
zval *value = Z_OBJ_HT_P(z)->get(z, &rv2);
if (z == &rv) {
zval_ptr_dtor(&rv);
}
ZVAL_COPY_VALUE(z, value);
}
zptr = z;
ZVAL_DEREF(z);
SEPARATE_ZVAL_NOREF(z);
binary_op(z, z, value);
Z_OBJ_HT(obj)->write_property(&obj, property, z, cache_slot);
if (UNEXPECTED(result)) {
ZVAL_COPY(result, z);
}
zval_ptr_dtor(zptr);
} else {
zend_error(E_WARNING, "Attempt to assign property of non-object");
if (UNEXPECTED(result)) {
ZVAL_NULL(result);
}
}
OBJ_RELEASE(Z_OBJ(obj));
}
1999-04-08 02:10:10 +08:00
/* Utility Functions for Extensions */
2014-12-14 06:06:14 +08:00
static void zend_extension_statement_handler(const zend_extension *extension, zend_op_array *op_array)
1999-04-08 02:10:10 +08:00
{
if (extension->statement_handler) {
extension->statement_handler(op_array);
}
}
2014-12-14 06:06:14 +08:00
static void zend_extension_fcall_begin_handler(const zend_extension *extension, zend_op_array *op_array)
1999-04-08 02:10:10 +08:00
{
if (extension->fcall_begin_handler) {
extension->fcall_begin_handler(op_array);
}
}
2014-12-14 06:06:14 +08:00
static void zend_extension_fcall_end_handler(const zend_extension *extension, zend_op_array *op_array)
1999-04-08 02:10:10 +08:00
{
if (extension->fcall_end_handler) {
extension->fcall_end_handler(op_array);
}
}
2014-12-14 06:06:14 +08:00
static zend_always_inline HashTable *zend_get_target_symbol_table(zend_execute_data *execute_data, int fetch_type)
1999-04-08 02:10:10 +08:00
{
2014-04-08 04:38:54 +08:00
HashTable *ht;
2015-01-03 17:22:58 +08:00
if (EXPECTED(fetch_type == ZEND_FETCH_GLOBAL_LOCK) ||
2014-04-08 04:38:54 +08:00
EXPECTED(fetch_type == ZEND_FETCH_GLOBAL)) {
ht = &EG(symbol_table);
2014-04-08 04:38:54 +08:00
} else if (EXPECTED(fetch_type == ZEND_FETCH_STATIC)) {
ZEND_ASSERT(EX(func)->op_array.static_variables != NULL);
ht = EX(func)->op_array.static_variables;
if (GC_REFCOUNT(ht) > 1) {
if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
GC_REFCOUNT(ht)--;
}
EX(func)->op_array.static_variables = ht = zend_array_dup(ht);
}
2014-04-08 04:38:54 +08:00
} else {
ZEND_ASSERT(fetch_type == ZEND_FETCH_LOCAL);
if (!EX(symbol_table)) {
2014-12-14 06:06:14 +08:00
zend_rebuild_symbol_table();
2014-04-08 04:38:54 +08:00
}
ht = EX(symbol_table);
1999-04-08 02:10:10 +08:00
}
2014-04-08 04:38:54 +08:00
return ht;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type)
1999-04-08 02:10:10 +08:00
{
zval *retval;
zend_string *offset_key;
2014-08-26 01:24:55 +08:00
zend_ulong hval;
1999-04-08 02:10:10 +08:00
try_again:
2014-08-26 01:24:55 +08:00
if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
hval = Z_LVAL_P(dim);
2014-04-05 05:56:51 +08:00
num_index:
retval = zend_hash_index_find(ht, hval);
if (retval == NULL) {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE,"Undefined offset: " ZEND_LONG_FMT, hval);
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_UNSET:
case BP_VAR_IS:
retval = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
zend_error(E_NOTICE,"Undefined offset: " ZEND_LONG_FMT, hval);
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_W:
2014-05-27 04:38:58 +08:00
retval = zend_hash_index_add_new(ht, hval, &EG(uninitialized_zval));
2014-04-05 05:56:51 +08:00
break;
}
2014-04-05 05:56:51 +08:00
}
} else if (EXPECTED(Z_TYPE_P(dim) == IS_STRING)) {
offset_key = Z_STR_P(dim);
if (dim_type != IS_CONST) {
if (ZEND_HANDLE_NUMERIC(offset_key, hval)) {
goto num_index;
}
2014-04-05 05:56:51 +08:00
}
str_index:
retval = zend_hash_find(ht, offset_key);
if (retval) {
/* support for $GLOBALS[...] */
if (UNEXPECTED(Z_TYPE_P(retval) == IS_INDIRECT)) {
retval = Z_INDIRECT_P(retval);
if (UNEXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) {
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key));
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_UNSET:
case BP_VAR_IS:
retval = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
zend_error(E_NOTICE,"Undefined index: %s", ZSTR_VAL(offset_key));
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_W:
ZVAL_NULL(retval);
break;
}
}
1999-04-08 02:10:10 +08:00
}
2015-01-03 17:22:58 +08:00
} else {
2014-04-05 05:56:51 +08:00
switch (type) {
case BP_VAR_R:
zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key));
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_UNSET:
case BP_VAR_IS:
retval = &EG(uninitialized_zval);
break;
case BP_VAR_RW:
zend_error(E_NOTICE,"Undefined index: %s", ZSTR_VAL(offset_key));
2014-04-05 05:56:51 +08:00
/* break missing intentionally */
case BP_VAR_W:
retval = zend_hash_add_new(ht, offset_key, &EG(uninitialized_zval));
2014-04-05 05:56:51 +08:00
break;
1999-04-08 02:10:10 +08:00
}
2014-04-05 05:56:51 +08:00
}
} else {
switch (Z_TYPE_P(dim)) {
case IS_NULL:
offset_key = ZSTR_EMPTY_ALLOC();
2014-04-05 05:56:51 +08:00
goto str_index;
case IS_DOUBLE:
2014-08-26 01:24:55 +08:00
hval = zend_dval_to_lval(Z_DVAL_P(dim));
2014-04-05 05:56:51 +08:00
goto num_index;
case IS_RESOURCE:
zend_error(E_NOTICE, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim));
2014-04-05 05:56:51 +08:00
hval = Z_RES_HANDLE_P(dim);
goto num_index;
case IS_FALSE:
hval = 0;
goto num_index;
case IS_TRUE:
hval = 1;
2014-04-05 05:56:51 +08:00
goto num_index;
case IS_REFERENCE:
dim = Z_REFVAL_P(dim);
goto try_again;
2014-04-05 05:56:51 +08:00
default:
zend_error(E_WARNING, "Illegal offset type");
retval = (type == BP_VAR_W || type == BP_VAR_RW) ?
&EG(error_zval) : &EG(uninitialized_zval);
}
1999-04-08 02:10:10 +08:00
}
return retval;
}
2014-12-14 06:06:14 +08:00
static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type)
{
zend_long offset;
try_again:
if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
switch(Z_TYPE_P(dim)) {
case IS_STRING:
if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
break;
}
if (type != BP_VAR_UNSET) {
zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim));
}
break;
case IS_DOUBLE:
case IS_NULL:
case IS_FALSE:
case IS_TRUE:
zend_error(E_NOTICE, "String offset cast occurred");
break;
case IS_REFERENCE:
dim = Z_REFVAL_P(dim);
goto try_again;
default:
zend_error(E_WARNING, "Illegal offset type");
break;
}
offset = zval_get_long(dim);
} else {
offset = Z_LVAL_P(dim);
}
return offset;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline zend_long zend_fetch_string_offset(zval *container, zval *dim, int type)
{
2014-12-14 06:06:14 +08:00
zend_long offset = zend_check_string_offset(dim, type);
if (Z_REFCOUNTED_P(container)) {
if (Z_REFCOUNT_P(container) > 1) {
Z_DELREF_P(container);
zval_copy_ctor_func(container);
}
Z_ADDREF_P(container);
}
return offset;
}
2014-12-14 06:06:14 +08:00
static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type)
1999-04-08 02:10:10 +08:00
{
zval *retval;
1999-04-08 02:10:10 +08:00
2014-04-05 05:56:51 +08:00
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
try_array:
SEPARATE_ARRAY(container);
2007-11-20 19:01:28 +08:00
fetch_from_array:
2014-04-05 05:56:51 +08:00
if (dim == NULL) {
retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
2014-09-22 17:18:49 +08:00
if (UNEXPECTED(retval == NULL)) {
2014-04-05 05:56:51 +08:00
zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
retval = &EG(error_zval);
}
2014-04-05 05:56:51 +08:00
} else {
2014-12-14 06:06:14 +08:00
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
2014-04-05 05:56:51 +08:00
}
2014-09-22 21:52:38 +08:00
ZVAL_INDIRECT(result, retval);
return;
} else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
container = Z_REFVAL_P(container);
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
goto try_array;
}
}
if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
2014-08-26 01:24:55 +08:00
if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRLEN_P(container) == 0)) {
zval_ptr_dtor_nogc(container);
2014-06-09 19:41:29 +08:00
convert_to_array:
ZVAL_NEW_ARR(container);
zend_hash_init(Z_ARRVAL_P(container), 8, NULL, ZVAL_PTR_DTOR, 0);
2014-04-05 05:56:51 +08:00
goto fetch_from_array;
}
2014-09-07 06:54:47 +08:00
if (dim == NULL) {
2015-07-04 05:04:33 +08:00
zend_throw_error(zend_ce_error, "[] operator not supported for strings");
ZVAL_NULL(result);
} else {
zend_check_string_offset(dim, type);
ZVAL_INDIRECT(result, NULL); /* wrong string offset */
}
2014-04-05 05:56:51 +08:00
} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
if (!Z_OBJ_HT_P(container)->read_dimension) {
2015-07-04 05:04:33 +08:00
zend_throw_error(zend_ce_error, "Cannot use object as array");
retval = &EG(error_zval);
2014-04-05 05:56:51 +08:00
} else {
2014-12-14 06:06:14 +08:00
retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result);
2014-04-05 05:56:51 +08:00
2014-04-10 03:49:58 +08:00
if (UNEXPECTED(retval == &EG(uninitialized_zval))) {
zend_class_entry *ce = Z_OBJCE_P(container);
2014-04-10 03:49:58 +08:00
ZVAL_NULL(result);
zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->name));
2014-09-22 17:18:49 +08:00
} else if (EXPECTED(retval && Z_TYPE_P(retval) != IS_UNDEF)) {
2014-04-05 05:56:51 +08:00
if (!Z_ISREF_P(retval)) {
if (Z_REFCOUNTED_P(retval) &&
Z_REFCOUNT_P(retval) > 1) {
if (Z_TYPE_P(retval) != IS_OBJECT) {
Z_DELREF_P(retval);
ZVAL_DUP(result, retval);
retval = result;
} else {
2014-04-05 05:56:51 +08:00
ZVAL_COPY(result, retval);
retval = result;
}
}
2014-04-05 05:56:51 +08:00
if (Z_TYPE_P(retval) != IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(container);
zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->name));
2014-04-05 05:56:51 +08:00
}
}
if (result != retval) {
2014-09-22 21:52:38 +08:00
ZVAL_INDIRECT(result, retval);
}
2007-12-14 22:14:50 +08:00
} else {
ZVAL_INDIRECT(result, &EG(error_zval));
2007-12-14 22:14:50 +08:00
}
2014-04-05 05:56:51 +08:00
}
2014-12-09 05:10:23 +08:00
} else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
2014-09-22 17:18:49 +08:00
if (UNEXPECTED(container == &EG(error_zval))) {
2014-04-05 05:56:51 +08:00
ZVAL_INDIRECT(result, &EG(error_zval));
} else if (type != BP_VAR_UNSET) {
goto convert_to_array;
} else {
/* for read-mode only */
ZVAL_NULL(result);
}
} else {
if (type == BP_VAR_UNSET) {
zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
ZVAL_NULL(result);
} else {
zend_error(E_WARNING, "Cannot use a scalar value as an array");
ZVAL_INDIRECT(result, &EG(error_zval));
}
2007-12-14 22:14:50 +08:00
}
}
2014-12-14 06:06:14 +08:00
static zend_never_inline void zend_fetch_dimension_address_W(zval *result, zval *container_ptr, zval *dim, int dim_type)
2007-12-14 22:14:50 +08:00
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_W);
2014-04-05 05:56:51 +08:00
}
2007-12-14 22:14:50 +08:00
2014-12-14 06:06:14 +08:00
static zend_never_inline void zend_fetch_dimension_address_RW(zval *result, zval *container_ptr, zval *dim, int dim_type)
2014-04-05 05:56:51 +08:00
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_RW);
2014-04-05 05:56:51 +08:00
}
2007-12-14 22:14:50 +08:00
2014-12-14 06:06:14 +08:00
static zend_never_inline void zend_fetch_dimension_address_UNSET(zval *result, zval *container_ptr, zval *dim, int dim_type)
2014-04-05 05:56:51 +08:00
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_UNSET);
2014-04-05 05:56:51 +08:00
}
2007-12-14 22:14:50 +08:00
2014-12-14 06:06:14 +08:00
static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type)
2014-04-05 05:56:51 +08:00
{
zval *retval;
2014-04-05 05:56:51 +08:00
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
try_array:
2014-12-14 06:06:14 +08:00
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
2014-04-05 05:56:51 +08:00
ZVAL_COPY(result, retval);
return;
} else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
container = Z_REFVAL_P(container);
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
goto try_array;
}
}
if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
2014-08-26 01:24:55 +08:00
zend_long offset;
2014-04-05 05:56:51 +08:00
try_string_offset:
2014-08-26 01:24:55 +08:00
if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
2014-04-05 05:56:51 +08:00
switch(Z_TYPE_P(dim)) {
2014-08-26 01:24:55 +08:00
/* case IS_LONG: */
2014-04-05 05:56:51 +08:00
case IS_STRING:
2014-08-26 01:24:55 +08:00
if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
2014-04-05 05:56:51 +08:00
break;
}
if (type == BP_VAR_IS) {
ZVAL_NULL(result);
return;
}
zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim));
2014-04-05 05:56:51 +08:00
break;
case IS_DOUBLE:
case IS_NULL:
case IS_FALSE:
case IS_TRUE:
2014-04-05 05:56:51 +08:00
if (type != BP_VAR_IS) {
zend_error(E_NOTICE, "String offset cast occurred");
}
2014-04-05 05:56:51 +08:00
break;
case IS_REFERENCE:
dim = Z_REFVAL_P(dim);
goto try_string_offset;
2014-04-05 05:56:51 +08:00
default:
zend_error(E_WARNING, "Illegal offset type");
break;
2007-12-14 22:14:50 +08:00
}
2014-08-26 01:24:55 +08:00
offset = zval_get_long(dim);
} else {
2014-08-26 01:24:55 +08:00
offset = Z_LVAL_P(dim);
2014-04-05 05:56:51 +08:00
}
if (UNEXPECTED(offset < 0) || UNEXPECTED(Z_STRLEN_P(container) <= (size_t)offset)) {
2014-04-05 05:56:51 +08:00
if (type != BP_VAR_IS) {
2014-09-03 21:57:28 +08:00
zend_error(E_NOTICE, "Uninitialized string offset: %pd", offset);
ZVAL_EMPTY_STRING(result);
} else {
ZVAL_NULL(result);
2014-04-05 05:56:51 +08:00
}
} else {
zend_uchar c = (zend_uchar)Z_STRVAL_P(container)[offset];
2014-04-05 05:56:51 +08:00
if (CG(one_char_string)[c]) {
2014-08-26 01:28:33 +08:00
ZVAL_INTERNED_STR(result, CG(one_char_string)[c]);
2007-12-14 22:14:50 +08:00
} else {
2014-08-26 01:24:55 +08:00
ZVAL_NEW_STR(result, zend_string_init(Z_STRVAL_P(container) + offset, 1, 0));
2014-04-05 05:56:51 +08:00
}
}
} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
if (!Z_OBJ_HT_P(container)->read_dimension) {
2015-07-04 05:04:33 +08:00
zend_throw_error(zend_ce_error, "Cannot use object as array");
ZVAL_NULL(result);
2014-04-05 05:56:51 +08:00
} else {
2014-12-14 06:06:14 +08:00
retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result);
2014-04-05 05:56:51 +08:00
2014-10-03 18:35:05 +08:00
ZEND_ASSERT(result != NULL);
if (retval) {
if (result != retval) {
ZVAL_COPY(result, retval);
2007-12-14 22:14:50 +08:00
}
2014-10-03 18:35:05 +08:00
} else {
ZVAL_NULL(result);
1999-04-08 02:10:10 +08:00
}
2014-04-05 05:56:51 +08:00
}
} else {
ZVAL_NULL(result);
1999-04-08 02:10:10 +08:00
}
}
2014-12-14 06:06:14 +08:00
static zend_never_inline void zend_fetch_dimension_address_read_R(zval *result, zval *container, zval *dim, int dim_type)
2014-04-05 05:56:51 +08:00
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R);
2014-04-05 05:56:51 +08:00
}
2014-12-14 06:06:14 +08:00
static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result, zval *container, zval *dim, int dim_type)
2014-04-05 05:56:51 +08:00
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS);
2014-04-05 05:56:51 +08:00
}
2014-12-14 06:06:14 +08:00
ZEND_API void zend_fetch_dimension_by_zval(zval *result, zval *container, zval *dim)
{
2014-12-14 06:06:14 +08:00
zend_fetch_dimension_address_read_R(result, container, dim, IS_TMP_VAR);
}
2014-12-14 06:06:14 +08:00
static zend_always_inline void zend_fetch_property_address(zval *result, zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, void **cache_slot, int type)
1999-04-08 02:10:10 +08:00
{
if (container_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
do {
2015-04-09 04:15:43 +08:00
if (container_op_type == IS_VAR && UNEXPECTED(container == &EG(error_zval))) {
ZVAL_INDIRECT(result, &EG(error_zval));
return;
}
if (Z_ISREF_P(container)) {
container = Z_REFVAL_P(container);
if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
break;
}
}
/* this should modify object only if it's empty */
if (type != BP_VAR_UNSET &&
2014-12-09 05:10:23 +08:00
EXPECTED(Z_TYPE_P(container) <= IS_FALSE ||
(Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0))) {
zval_ptr_dtor_nogc(container);
object_init(container);
} else {
zend_error(E_WARNING, "Attempt to modify property of non-object");
ZVAL_INDIRECT(result, &EG(error_zval));
return;
}
} while (0);
1999-04-08 02:10:10 +08:00
}
2014-11-06 19:50:03 +08:00
if (prop_op_type == IS_CONST &&
EXPECTED(Z_OBJCE_P(container) == CACHED_PTR_EX(cache_slot))) {
uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
2014-11-06 19:50:03 +08:00
zend_object *zobj = Z_OBJ_P(container);
zval *retval;
2015-02-26 04:20:47 +08:00
if (EXPECTED(prop_offset != (uint32_t)ZEND_DYNAMIC_PROPERTY_OFFSET)) {
retval = OBJ_PROP(zobj, prop_offset);
2014-11-06 19:50:03 +08:00
if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
ZVAL_INDIRECT(result, retval);
return;
}
} else if (EXPECTED(zobj->properties != NULL)) {
retval = zend_hash_find(zobj->properties, Z_STR_P(prop_ptr));
if (EXPECTED(retval)) {
ZVAL_INDIRECT(result, retval);
return;
}
}
}
2014-09-22 17:18:49 +08:00
if (EXPECTED(Z_OBJ_HT_P(container)->get_property_ptr_ptr)) {
2014-12-14 06:06:14 +08:00
zval *ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, cache_slot);
if (NULL == ptr) {
if (Z_OBJ_HT_P(container)->read_property &&
2014-12-14 06:06:14 +08:00
(ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result)) != NULL) {
if (ptr != result) {
2014-09-22 21:52:38 +08:00
ZVAL_INDIRECT(result, ptr);
}
} else {
2015-07-04 05:04:33 +08:00
zend_throw_error(zend_ce_error, "Cannot access undefined property for object with overloaded property access");
ZVAL_INDIRECT(result, &EG(error_zval));
}
2008-01-24 01:55:55 +08:00
} else {
2014-09-22 21:52:38 +08:00
ZVAL_INDIRECT(result, ptr);
}
2014-09-22 17:18:49 +08:00
} else if (EXPECTED(Z_OBJ_HT_P(container)->read_property)) {
2014-12-14 06:06:14 +08:00
zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result);
if (ptr != result) {
2014-09-22 21:52:38 +08:00
ZVAL_INDIRECT(result, ptr);
}
} else {
zend_error(E_WARNING, "This object doesn't support property references");
2014-02-26 03:39:25 +08:00
ZVAL_INDIRECT(result, &EG(error_zval));
}
1999-04-08 02:10:10 +08:00
}
2014-12-14 06:06:14 +08:00
static inline zend_brk_cont_element* zend_brk_cont(int nest_levels, int array_offset, const zend_op_array *op_array, const zend_execute_data *execute_data)
{
zend_brk_cont_element *jmp_to;
do {
ZEND_ASSERT(array_offset != -1);
jmp_to = &op_array->brk_cont_array[array_offset];
if (nest_levels > 1 && jmp_to->start >= 0) {
zend_op *brk_opline = &op_array->opcodes[jmp_to->brk];
2004-09-10 00:47:22 +08:00
if (brk_opline->opcode == ZEND_FREE) {
zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var));
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 18:57:12 +08:00
} else if (brk_opline->opcode == ZEND_FE_FREE) {
zval *var = EX_VAR(brk_opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
Fix "forech" statemt behaviour according to https://wiki.php.net/rfc/php7_foreach Squashed commit of the following: commit 1e41295097576dbce6c197ddb7507c07ccae3cbe Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Jan 31 07:28:58 2015 +0300 Generalize HashTableIterator API to allows its usage without involvement of HashTable.nInternalPonter commit 5406f21b11e563069d64045e599693b51c444b63 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:43 2015 +0300 Reduced alghorithms complexity commit b37f1d58d2a141b6e1d980a461ccb588d4317d2e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:30 2015 +0300 Fixed test name commit fb2d079645829b12ed4e55a461034df6400bc430 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 18:08:05 2015 +0300 API cleanup commit 08302c0d6d1cab279b9f2129df03a057baddf2ff Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 14:20:46 2015 +0300 Make array_splice() to preserve foreach hash position commit cc4b7be41e2e2b9b0d7a3c8e98466b8886692e6e Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 12:24:31 2015 +0300 Make internal function, operation on array passed by reference, to preserve foreach hash position commit 5aa9712b0a30303aadfe3bdd8ae1f072ca3e6ba1 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 09:49:35 2015 +0300 Implement consistent behavior for foreach by value over plain object commit 4c5b385ff53ae9f0b52572e98c4db801f56603b0 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Jan 30 07:56:37 2015 +0300 More careful iterators update. commit 721fc9e80d2ee8f2cd79c8c3cdceffae2c72de92 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:43:28 2015 +0300 Added new test commit 15a23b1218b3e38630d677751a975907daa2cd54 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:05:02 2015 +0300 Reimplement iteration magic with HashTableIterators (see https://wiki.php.net/rfc/php7_foreach#implementation_details) commit 10a3260b1f16b6075fd8140f673dfef4d5efea91 Author: Dmitry Stogov <dmitry@zend.com> Date: Thu Jan 29 21:04:44 2015 +0300 New test commit eef80c583762d1e98d177cdbb27e3a8a6b0c4539 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 16:52:21 2015 +0300 Fixed foreach by reference iteration over constant array commit 61e739187391661e2d541947bec25d7dcc4479f3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 14:59:54 2015 +0300 Fixed temporary variable re-allocation pass commit 92e90c09f085c22707ff4a59201f016f56e0ef8b Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 12:44:57 2015 +0300 Fixed operand destruction in case of exceptions in iterator commit dd2a36a2074bbb0cb31de00b66dcf2812d6d753f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 10:02:34 2015 +0300 Use GET_OP1_ZVAL_PTR_DEREF() (IS_TMP_VAR and IS_CONST can't be IS_REFERENCE) commit 4638f7b91407c48710007af82a68da0007c820f2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Jan 28 07:43:28 2015 +0300 Change "foreach" statement behavior (this is just a PoC yet) - "foreach by value" don't relay on internal array/object pointer and doesnt perform array duplication. It just locks it incrementing reference counter. If the original array is modified by some code, the copy on write is performed and "foreach" still work with the old copy. - it makes no difference if array given to "foreach by value" is reference itself - "foreach by reference" still use internal array/object pointer and should work similar to PHP-5. (This id not completely implemented)
2015-02-12 18:57:12 +08:00
}
zval_ptr_dtor_nogc(var);
2004-09-10 00:47:22 +08:00
}
}
array_offset = jmp_to->parent;
} while (--nest_levels > 0);
return jmp_to;
}
#if ZEND_INTENSIVE_DEBUGGING
#define CHECK_SYMBOL_TABLES() \
2014-12-14 06:06:14 +08:00
zend_hash_apply(&EG(symbol_table), zend_check_symbol); \
if (&EG(symbol_table)!=EX(symbol_table)) { \
2014-12-14 06:06:14 +08:00
zend_hash_apply(EX(symbol_table), zend_check_symbol); \
}
2014-12-14 06:06:14 +08:00
static int zend_check_symbol(zval *pz)
{
if (Z_TYPE_P(pz) == IS_INDIRECT) {
pz = Z_INDIRECT_P(pz);
}
if (Z_TYPE_P(pz) > 10) {
fprintf(stderr, "Warning! %x has invalid type!\n", *pz);
/* See http://support.microsoft.com/kb/190351 */
#ifdef PHP_WIN32
fflush(stderr);
#endif
} else if (Z_TYPE_P(pz) == IS_ARRAY) {
2014-12-14 06:06:14 +08:00
zend_hash_apply(Z_ARRVAL_P(pz), zend_check_symbol);
} else if (Z_TYPE_P(pz) == IS_OBJECT) {
/* OBJ-TBI - doesn't support new object model! */
2014-12-14 06:06:14 +08:00
zend_hash_apply(Z_OBJPROP_P(pz), zend_check_symbol);
}
return 0;
}
#else
#define CHECK_SYMBOL_TABLES()
#endif
2014-12-14 06:06:14 +08:00
ZEND_API void execute_internal(zend_execute_data *execute_data, zval *return_value)
{
2014-12-14 06:06:14 +08:00
execute_data->func->internal_function.handler(execute_data, return_value);
}
2014-12-14 06:06:14 +08:00
ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table) /* {{{ */
{
if (EG(symtable_cache_ptr) >= EG(symtable_cache_limit)) {
zend_array_destroy(symbol_table);
} else {
/* clean before putting into the cache, since clean
could call dtors, which could use cached hash */
zend_symtable_clean(symbol_table);
*(++EG(symtable_cache_ptr)) = symbol_table;
}
}
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_always_inline void i_free_compiled_variables(zend_execute_data *execute_data) /* {{{ */
{
zval *cv = EX_VAR_NUM(0);
zval *end = cv + EX(func)->op_array.last_var;
while (EXPECTED(cv != end)) {
if (Z_REFCOUNTED_P(cv)) {
if (!Z_DELREF_P(cv)) {
zend_refcounted *r = Z_COUNTED_P(cv);
ZVAL_NULL(cv);
zval_dtor_func_for_ptr(r);
} else {
GC_ZVAL_CHECK_POSSIBLE_ROOT(cv);
}
}
cv++;
}
2012-12-05 17:23:37 +08:00
}
/* }}} */
2014-12-14 06:06:14 +08:00
void zend_free_compiled_variables(zend_execute_data *execute_data) /* {{{ */
2012-12-05 17:23:37 +08:00
{
2014-12-14 06:06:14 +08:00
i_free_compiled_variables(execute_data);
}
/* }}} */
2015-03-17 00:48:29 +08:00
#ifdef ZEND_WIN32
# define ZEND_VM_INTERRUPT_CHECK() do { \
if (EG(timed_out)) { \
zend_timeout(0); \
} \
} while (0)
#else
# define ZEND_VM_INTERRUPT_CHECK() do { \
} while (0)
#endif
/*
* Stack Frame Layout (the whole stack frame is allocated at once)
* ==================
*
* +========================================+
* EG(current_execute_data) -> | zend_execute_data |
* +----------------------------------------+
* EX_CV_NUM(0) ---------> | VAR[0] = ARG[1] |
* | ... |
* | VAR[op_array->num_args-1] = ARG[N] |
* | ... |
* | VAR[op_array->last_var-1] |
* | VAR[op_array->last_var] = TMP[0] |
* | ... |
* | VAR[op_array->last_var+op_array->T-1] |
* | ARG[N+1] (extra_args) |
* | ... |
* +----------------------------------------+
*/
static zend_always_inline void i_init_func_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value, int check_this) /* {{{ */
{
2014-09-17 20:17:58 +08:00
uint32_t first_extra_arg, num_args;
ZEND_ASSERT(EX(func) == (zend_function*)op_array);
2014-07-08 01:33:09 +08:00
EX(opline) = op_array->opcodes;
2014-09-17 20:17:58 +08:00
EX(call) = NULL;
EX(return_value) = return_value;
2014-09-17 20:17:58 +08:00
/* Handle arguments */
first_extra_arg = op_array->num_args;
num_args = EX_NUM_ARGS();
2014-09-17 20:17:58 +08:00
if (UNEXPECTED(num_args > first_extra_arg)) {
zval *end, *src, *dst;
uint32_t type_flags = 0;
2014-09-17 20:17:58 +08:00
if (EXPECTED((op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) == 0)) {
/* Skip useless ZEND_RECV and ZEND_RECV_INIT opcodes */
EX(opline) += first_extra_arg;
}
2014-09-17 20:17:58 +08:00
/* move extra args into separate array after all CV and TMP vars */
end = EX_VAR_NUM(first_extra_arg - 1);
src = end + (num_args - first_extra_arg);
dst = src + (op_array->last_var + op_array->T - first_extra_arg);
if (EXPECTED(src != dst)) {
do {
type_flags |= Z_TYPE_INFO_P(src);
2014-09-17 20:17:58 +08:00
ZVAL_COPY_VALUE(dst, src);
ZVAL_UNDEF(src);
src--;
dst--;
} while (src != end);
} else {
do {
type_flags |= Z_TYPE_INFO_P(src);
src--;
} while (src != end);
}
ZEND_ADD_CALL_FLAG(execute_data, ((type_flags >> Z_TYPE_FLAGS_SHIFT) & IS_TYPE_REFCOUNTED));
2014-09-17 20:17:58 +08:00
} else if (EXPECTED((op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) == 0)) {
/* Skip useless ZEND_RECV and ZEND_RECV_INIT opcodes */
EX(opline) += num_args;
}
/* Initialize CV variables (skip arguments) */
2014-10-13 17:49:10 +08:00
if (EXPECTED((int)num_args < op_array->last_var)) {
2014-09-17 20:17:58 +08:00
zval *var = EX_VAR_NUM(num_args);
zval *end = EX_VAR_NUM(op_array->last_var);
do {
ZVAL_UNDEF(var);
var++;
} while (var != end);
}
if (check_this && op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
GC_REFCOUNT(Z_OBJ(EX(This)))++;
}
2014-12-13 02:57:12 +08:00
if (UNEXPECTED(!op_array->run_time_cache)) {
op_array->run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size);
memset(op_array->run_time_cache, 0, op_array->cache_size);
}
EX_LOAD_RUN_TIME_CACHE(op_array);
EX_LOAD_LITERALS(op_array);
EG(current_execute_data) = execute_data;
2015-03-17 00:48:29 +08:00
ZEND_VM_INTERRUPT_CHECK();
}
2014-07-08 17:53:13 +08:00
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_always_inline void i_init_code_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */
{
ZEND_ASSERT(EX(func) == (zend_function*)op_array);
EX(opline) = op_array->opcodes;
2014-09-17 20:17:58 +08:00
EX(call) = NULL;
EX(return_value) = return_value;
zend_attach_symbol_table(execute_data);
2014-12-13 02:57:34 +08:00
if (op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
GC_REFCOUNT(Z_OBJ(EX(This)))++;
}
2014-12-13 02:57:12 +08:00
if (!op_array->run_time_cache) {
op_array->run_time_cache = emalloc(op_array->cache_size);
memset(op_array->run_time_cache, 0, op_array->cache_size);
}
EX_LOAD_RUN_TIME_CACHE(op_array);
EX_LOAD_LITERALS(op_array);
EG(current_execute_data) = execute_data;
2015-03-17 00:48:29 +08:00
ZEND_VM_INTERRUPT_CHECK();
}
2014-07-08 17:53:13 +08:00
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_always_inline void i_init_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */
{
ZEND_ASSERT(EX(func) == (zend_function*)op_array);
EX(opline) = op_array->opcodes;
2014-09-17 20:17:58 +08:00
EX(call) = NULL;
EX(return_value) = return_value;
if (UNEXPECTED(EX(symbol_table) != NULL)) {
2014-04-18 17:46:36 +08:00
zend_attach_symbol_table(execute_data);
} else {
2014-09-17 20:17:58 +08:00
uint32_t first_extra_arg, num_args;
2015-01-03 17:22:58 +08:00
2014-09-17 20:17:58 +08:00
/* Handle arguments */
first_extra_arg = op_array->num_args;
num_args = EX_NUM_ARGS();
2014-09-17 20:17:58 +08:00
if (UNEXPECTED(num_args > first_extra_arg)) {
zval *end, *src, *dst;
uint32_t type_flags = 0;
2014-09-17 20:17:58 +08:00
if (EXPECTED((op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) == 0)) {
/* Skip useless ZEND_RECV and ZEND_RECV_INIT opcodes */
EX(opline) += first_extra_arg;
}
2014-09-17 20:17:58 +08:00
/* move extra args into separate array after all CV and TMP vars */
end = EX_VAR_NUM(first_extra_arg - 1);
src = end + (num_args - first_extra_arg);
dst = src + (op_array->last_var + op_array->T - first_extra_arg);
if (EXPECTED(src != dst)) {
do {
type_flags |= Z_TYPE_INFO_P(src);
2014-09-17 20:17:58 +08:00
ZVAL_COPY_VALUE(dst, src);
ZVAL_UNDEF(src);
src--;
dst--;
} while (src != end);
} else {
do {
type_flags |= Z_TYPE_INFO_P(src);
src--;
} while (src != end);
}
ZEND_ADD_CALL_FLAG(execute_data, ((type_flags >> Z_TYPE_FLAGS_SHIFT) & IS_TYPE_REFCOUNTED));
2014-09-17 20:17:58 +08:00
} else if (EXPECTED((op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) == 0)) {
/* Skip useless ZEND_RECV and ZEND_RECV_INIT opcodes */
EX(opline) += num_args;
}
/* Initialize CV variables (skip arguments) */
2014-10-13 17:49:10 +08:00
if (EXPECTED((int)num_args < op_array->last_var)) {
2014-09-17 20:17:58 +08:00
zval *var = EX_VAR_NUM(num_args);
zval *end = EX_VAR_NUM(op_array->last_var);
do {
ZVAL_UNDEF(var);
var++;
} while (var != end);
}
}
2014-12-13 02:57:34 +08:00
if (op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
GC_REFCOUNT(Z_OBJ(EX(This)))++;
}
2014-12-13 02:57:12 +08:00
if (!op_array->run_time_cache) {
if (op_array->function_name) {
op_array->run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size);
} else {
op_array->run_time_cache = emalloc(op_array->cache_size);
}
memset(op_array->run_time_cache, 0, op_array->cache_size);
}
EX_LOAD_RUN_TIME_CACHE(op_array);
EX_LOAD_LITERALS(op_array);
EG(current_execute_data) = execute_data;
2015-03-17 00:48:29 +08:00
ZEND_VM_INTERRUPT_CHECK();
}
/* }}} */
2014-12-14 06:06:14 +08:00
ZEND_API zend_execute_data *zend_create_generator_execute_data(zend_execute_data *call, zend_op_array *op_array, zval *return_value) /* {{{ */
{
/*
* Normally the execute_data is allocated on the VM stack (because it does
* not actually do any allocation and thus is faster). For generators
* though this behavior would be suboptimal, because the (rather large)
* structure would have to be copied back and forth every time execution is
* suspended or resumed. That's why for generators the execution context
* is allocated using a separate VM stack, thus allowing to save and
* restore it simply by replacing a pointer.
*/
zend_execute_data *execute_data;
uint32_t num_args = ZEND_CALL_NUM_ARGS(call);
2014-09-29 23:41:00 +08:00
size_t stack_size = (ZEND_CALL_FRAME_SLOT + MAX(op_array->last_var + op_array->T, num_args)) * sizeof(zval);
uint32_t call_info;
EG(vm_stack) = zend_vm_stack_new_page(
EXPECTED(stack_size < ZEND_VM_STACK_FREE_PAGE_SIZE(1)) ?
ZEND_VM_STACK_PAGE_SIZE(1) :
ZEND_VM_STACK_PAGE_ALIGNED_SIZE(1, stack_size),
2014-09-29 23:41:00 +08:00
NULL);
EG(vm_stack_top) = EG(vm_stack)->top;
EG(vm_stack_end) = EG(vm_stack)->end;
call_info = ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | (ZEND_CALL_INFO(call) & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS));
if (Z_OBJ(call->This)) {
call_info |= ZEND_CALL_RELEASE_THIS;
}
execute_data = zend_vm_stack_push_call_frame(
call_info,
(zend_function*)op_array,
num_args,
2014-07-07 19:50:44 +08:00
call->called_scope,
Z_OBJ(call->This));
EX(prev_execute_data) = NULL;
EX_NUM_ARGS() = num_args;
/* copy arguments */
if (num_args > 0) {
2014-07-07 19:50:44 +08:00
zval *arg_src = ZEND_CALL_ARG(call, 1);
zval *arg_dst = ZEND_CALL_ARG(execute_data, 1);
2015-04-29 00:11:45 +08:00
zval *end = arg_src + num_args;
2015-04-29 00:11:45 +08:00
do {
ZVAL_COPY_VALUE(arg_dst, arg_src);
arg_src++;
arg_dst++;
} while (arg_src != end);
}
EX(symbol_table) = NULL;
i_init_func_execute_data(execute_data, op_array, return_value, 1);
return execute_data;
}
/* }}} */
2014-12-14 06:06:14 +08:00
ZEND_API void zend_init_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */
2012-12-05 17:23:37 +08:00
{
EX(prev_execute_data) = EG(current_execute_data);
2014-12-14 06:06:14 +08:00
i_init_execute_data(execute_data, op_array, return_value);
2012-12-05 17:23:37 +08:00
}
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_always_inline zend_bool zend_is_by_ref_func_arg_fetch(const zend_op *opline, zend_execute_data *call) /* {{{ */
{
2014-08-26 01:28:33 +08:00
uint32_t arg_num = opline->extended_value & ZEND_FETCH_ARG_MASK;
return ARG_SHOULD_BE_SENT_BY_REF(call->func, arg_num);
}
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call, uint32_t passed_args, uint32_t additional_args) /* {{{ */
{
zend_execute_data *new_call;
int used_stack = (EG(vm_stack_top) - (zval*)call) + additional_args;
2015-01-03 17:22:58 +08:00
/* copy call frame into new stack segment */
2014-12-14 06:06:14 +08:00
new_call = zend_vm_stack_extend(used_stack * sizeof(zval));
*new_call = *call;
ZEND_SET_CALL_INFO(new_call, ZEND_CALL_INFO(new_call) | ZEND_CALL_ALLOCATED);
if (passed_args) {
zval *src = ZEND_CALL_ARG(call, 1);
zval *dst = ZEND_CALL_ARG(new_call, 1);
do {
ZVAL_COPY_VALUE(dst, src);
passed_args--;
src++;
dst++;
} while (passed_args);
}
/* delete old call_frame from previous stack segment */
EG(vm_stack)->prev->top = (zval*)call;
/* delete previous stack segment if it becames empty */
if (UNEXPECTED(EG(vm_stack)->prev->top == ZEND_VM_STACK_ELEMETS(EG(vm_stack)->prev))) {
zend_vm_stack r = EG(vm_stack)->prev;
EG(vm_stack)->prev = r->prev;
efree(r);
}
return new_call;
}
/* }}} */
2014-12-14 06:06:14 +08:00
static zend_always_inline void zend_vm_stack_extend_call_frame(zend_execute_data **call, uint32_t passed_args, uint32_t additional_args) /* {{{ */
{
2015-02-26 04:20:47 +08:00
if (EXPECTED((uint32_t)(EG(vm_stack_end) - EG(vm_stack_top)) > additional_args)) {
EG(vm_stack_top) += additional_args;
} else {
2014-12-14 06:06:14 +08:00
*call = zend_vm_stack_copy_call_frame(*call, passed_args, additional_args);
}
}
/* }}} */
2015-02-20 19:59:56 +08:00
static zend_always_inline zend_generator *zend_get_running_generator(zend_execute_data *execute_data) /* {{{ */
{
/* The generator object is stored in EX(return_value) */
zend_generator *generator = (zend_generator *) EX(return_value);
/* However control may currently be delegated to another generator.
* That's the one we're interested in. */
2015-03-07 07:28:12 +08:00
return generator;
2015-02-20 19:59:56 +08:00
}
/* }}} */
static zend_always_inline void i_cleanup_unfinished_execution(zend_execute_data *execute_data, uint32_t op_num, uint32_t catch_op_num) /* {{{ */
{
int i;
if (UNEXPECTED(EX(call))) {
zend_execute_data *call = EX(call);
zend_op *opline = EX(func)->op_array.opcodes + op_num;
int level;
int do_exit;
do {
/* If the exception was thrown during a function call there might be
* arguments pushed to the stack that have to be dtor'ed. */
/* find the number of actually passed arguments */
level = 0;
do_exit = 0;
do {
switch (opline->opcode) {
case ZEND_DO_FCALL:
case ZEND_DO_ICALL:
case ZEND_DO_UCALL:
case ZEND_DO_FCALL_BY_NAME:
level++;
break;
case ZEND_INIT_FCALL:
case ZEND_INIT_FCALL_BY_NAME:
case ZEND_INIT_NS_FCALL_BY_NAME:
case ZEND_INIT_DYNAMIC_CALL:
case ZEND_INIT_USER_CALL:
case ZEND_INIT_METHOD_CALL:
case ZEND_INIT_STATIC_METHOD_CALL:
case ZEND_NEW:
if (level == 0) {
ZEND_CALL_NUM_ARGS(call) = 0;
do_exit = 1;
}
level--;
break;
case ZEND_SEND_VAL:
case ZEND_SEND_VAL_EX:
case ZEND_SEND_VAR:
case ZEND_SEND_VAR_EX:
case ZEND_SEND_REF:
case ZEND_SEND_VAR_NO_REF:
case ZEND_SEND_USER:
if (level == 0) {
ZEND_CALL_NUM_ARGS(call) = opline->op2.num;
do_exit = 1;
}
break;
case ZEND_SEND_ARRAY:
case ZEND_SEND_UNPACK:
if (level == 0) {
do_exit = 1;
}
break;
}
if (!do_exit) {
opline--;
}
} while (!do_exit);
if (call->prev_execute_data) {
/* skip current call region */
level = 0;
do_exit = 0;
do {
switch (opline->opcode) {
case ZEND_DO_FCALL:
case ZEND_DO_ICALL:
case ZEND_DO_UCALL:
case ZEND_DO_FCALL_BY_NAME:
level++;
break;
case ZEND_INIT_FCALL:
case ZEND_INIT_FCALL_BY_NAME:
case ZEND_INIT_NS_FCALL_BY_NAME:
case ZEND_INIT_DYNAMIC_CALL:
case ZEND_INIT_USER_CALL:
case ZEND_INIT_METHOD_CALL:
case ZEND_INIT_STATIC_METHOD_CALL:
case ZEND_NEW:
if (level == 0) {
do_exit = 1;
}
level--;
break;
}
opline--;
} while (!do_exit);
}
zend_vm_stack_free_args(EX(call));
if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
if (ZEND_CALL_INFO(call) & ZEND_CALL_CTOR) {
if (!(ZEND_CALL_INFO(call) & ZEND_CALL_CTOR_RESULT_UNUSED)) {
GC_REFCOUNT(Z_OBJ(call->This))--;
}
if (GC_REFCOUNT(Z_OBJ(call->This)) == 1) {
zend_object_store_ctor_failed(Z_OBJ(call->This));
}
}
OBJ_RELEASE(Z_OBJ(call->This));
}
if (call->func->common.fn_flags & ZEND_ACC_CLOSURE) {
zend_object_release((zend_object *) call->func->common.prototype);
}
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
zend_string_release(call->func->common.function_name);
zend_free_trampoline(call->func);
}
EX(call) = call->prev_execute_data;
zend_vm_stack_free_call_frame(call);
call = EX(call);
} while (call);
}
for (i = 0; i < EX(func)->op_array.last_brk_cont; i++) {
const zend_brk_cont_element *brk_cont = &EX(func)->op_array.brk_cont_array[i];
if (brk_cont->start < 0) {
continue;
} else if (brk_cont->start > op_num) {
/* further blocks will not be relevant... */
break;
} else if (op_num < brk_cont->brk) {
if (!catch_op_num || catch_op_num >= brk_cont->brk) {
zend_op *brk_opline = &EX(func)->op_array.opcodes[brk_cont->brk];
if (brk_opline->opcode == ZEND_FREE) {
zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var));
} else if (brk_opline->opcode == ZEND_FE_FREE) {
zval *var = EX_VAR(brk_opline->op1.var);
if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) {
zend_hash_iterator_del(Z_FE_ITER_P(var));
}
zval_ptr_dtor_nogc(var);
2015-06-28 21:42:05 +08:00
} else if (brk_opline->opcode == ZEND_ROPE_END) {
zend_string **rope = (zend_string **) EX_VAR(brk_opline->op1.var);
zend_op *last = EX(func)->op_array.opcodes + op_num;
while (last->opcode != ZEND_ROPE_ADD && last->opcode != ZEND_ROPE_INIT) {
ZEND_ASSERT(last >= EX(func)->op_array.opcodes);
last--;
}
if (last->opcode == ZEND_ROPE_INIT) {
zend_string_release(*rope);
} else {
int j = last->extended_value;
do {
zend_string_release(rope[j]);
} while (j--);
}
} else if (brk_opline->opcode == ZEND_END_SILENCE) {
/* restore previous error_reporting value */
if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(brk_opline->op1.var)) != 0) {
EG(error_reporting) = Z_LVAL_P(EX_VAR(brk_opline->op1.var));
}
}
}
}
}
}
/* }}} */
void zend_cleanup_unfinished_execution(zend_execute_data *execute_data, uint32_t op_num, uint32_t catch_op_num) {
i_cleanup_unfinished_execution(execute_data, op_num, catch_op_num);
}
#ifdef HAVE_GCC_GLOBAL_REGS
# if defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(i386)
# define ZEND_VM_FP_GLOBAL_REG "%esi"
# define ZEND_VM_IP_GLOBAL_REG "%edi"
# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__x86_64__)
# define ZEND_VM_FP_GLOBAL_REG "%r14"
# define ZEND_VM_IP_GLOBAL_REG "%r15"
# elif defined(__GNUC__) && ZEND_GCC_VERSION >= 4008 && defined(__powerpc64__)
# define ZEND_VM_FP_GLOBAL_REG "r28"
# define ZEND_VM_IP_GLOBAL_REG "r29"
# endif
#endif
2012-12-05 17:23:37 +08:00
#define ZEND_VM_NEXT_OPCODE() \
CHECK_SYMBOL_TABLES() \
ZEND_VM_INC_OPCODE(); \
ZEND_VM_CONTINUE()
2015-03-17 00:48:29 +08:00
#define ZEND_VM_SET_NEXT_OPCODE(new_op) \
2012-12-05 17:23:37 +08:00
CHECK_SYMBOL_TABLES() \
OPLINE = new_op
2015-03-17 00:48:29 +08:00
#define ZEND_VM_SET_OPCODE(new_op) \
CHECK_SYMBOL_TABLES() \
OPLINE = new_op; \
ZEND_VM_INTERRUPT_CHECK()
#define ZEND_VM_SET_RELATIVE_OPCODE(opline, offset) \
ZEND_VM_SET_OPCODE(ZEND_OFFSET_TO_OPLINE(opline, offset))
2012-12-05 17:23:37 +08:00
#define ZEND_VM_JMP(new_op) \
if (EXPECTED(!EG(exception))) { \
ZEND_VM_SET_OPCODE(new_op); \
} else { \
LOAD_OPLINE(); \
} \
ZEND_VM_CONTINUE()
#define ZEND_VM_INC_OPCODE() \
OPLINE++
#ifndef VM_SMART_OPCODES
# define VM_SMART_OPCODES 1
#endif
#if VM_SMART_OPCODES
# define ZEND_VM_REPEATABLE_OPCODE \
do {
# define ZEND_VM_REPEAT_OPCODE(_opcode) \
} while (UNEXPECTED((++opline)->opcode == _opcode)); \
OPLINE = opline; \
ZEND_VM_CONTINUE()
# define ZEND_VM_SMART_BRANCH(_result, _check) do { \
int __result; \
if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
__result = (_result); \
} else if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
__result = !(_result); \
} else { \
break; \
} \
if ((_check) && UNEXPECTED(EG(exception))) { \
HANDLE_EXCEPTION(); \
} \
if (__result) { \
ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
} else { \
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
} \
ZEND_VM_CONTINUE(); \
} while (0)
#else
# define ZEND_VM_REPEATABLE_OPCODE
# define ZEND_VM_REPEAT_OPCODE(_opcode)
# define ZEND_VM_SMART_BRANCH(_result, _check)
#endif
2012-12-05 17:23:37 +08:00
#ifdef __GNUC__
# define ZEND_VM_GUARD(name) __asm__("#" #name)
#else
# define ZEND_VM_GUARD(name)
#endif
#define GET_OP1_UNDEF_CV(ptr, type) \
_get_zval_cv_lookup_ ## type(ptr, opline->op1.var, execute_data)
#define GET_OP2_UNDEF_CV(ptr, type) \
_get_zval_cv_lookup_ ## type(ptr, opline->op2.var, execute_data)
2012-12-05 17:23:37 +08:00
#include "zend_vm_execute.h"
ZEND_API int zend_set_user_opcode_handler(zend_uchar opcode, user_opcode_handler_t handler)
{
if (opcode != ZEND_USER_OPCODE) {
if (handler == NULL) {
/* restore the original handler */
zend_user_opcodes[opcode] = opcode;
} else {
zend_user_opcodes[opcode] = ZEND_USER_OPCODE;
}
zend_user_opcode_handlers[opcode] = handler;
return SUCCESS;
}
return FAILURE;
}
ZEND_API user_opcode_handler_t zend_get_user_opcode_handler(zend_uchar opcode)
{
return zend_user_opcode_handlers[opcode];
}
2014-12-14 06:06:14 +08:00
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) {
return get_zval_ptr(op_type, *node, execute_data, should_free, type);
2012-12-05 17:23:37 +08:00
}
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* indent-tabs-mode: t
* End:
*/