From: Andi Gutmans Date: Mon, 4 Oct 2004 19:54:35 +0000 (+0000) Subject: - Commit the variable fetch optimization. X-Git-Tag: PRE_NEW_VM_GEN_PATCH~100 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=db507dd153fa668fef95863afee4d04f33b80b85;p=php - Commit the variable fetch optimization. - Extensions which delete global variables need to use new special function - delete_global_variable() (I'm about to rename it) to remove them. - Will post to internals@ or via commit messages if there's anything else. --- diff --git a/Zend/Zend.m4 b/Zend/Zend.m4 index 83c764a058..f3b8a3d171 100644 --- a/Zend/Zend.m4 +++ b/Zend/Zend.m4 @@ -108,6 +108,22 @@ AC_ARG_ENABLE(debug, AC_DEFUN(LIBZEND_OTHER_CHECKS,[ +PHP_ARG_WITH(zend-vm,[virtual machine dispatch method], +[ --with-zend-vm=TYPE Sets virtual machine dispatch methos. Type is + one of "CALL" (default), "SWITCH" or "GOTO"], CALL, no) + +case $PHP_ZEND_VM in + SWITCH) + AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_SWITCH,[virtual machine dispatch method]) + ;; + GOTO) + AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_GOTO,[virtual machine dispatch method]) + ;; + *) + AC_DEFINE(ZEND_VM_KIND,ZEND_VM_KIND_CALL,[virtual machine dispatch method]) + ;; +esac + AC_ARG_ENABLE(maintainer-zts, [ --enable-maintainer-zts Enable thread safety - for code maintainers only],[ ZEND_MAINTAINER_ZTS=$enableval diff --git a/Zend/zend_API.h b/Zend/zend_API.h index e5d3927c9b..1466308456 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -333,6 +333,8 @@ ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...); +ZEND_API int delete_global_variable(char *name, int name_len TSRMLS_DC); + #define add_method(arg, key, method) add_assoc_function((arg), (key), (method)) ZEND_API ZEND_FUNCTION(display_disabled_function); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 913be149e7..2f34969a02 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -221,6 +221,32 @@ static zend_uint get_temporary_variable(zend_op_array *op_array) return (op_array->T)++ * sizeof(temp_variable); } +static int lookup_cv(zend_op_array *op_array, char* name, int name_len) +{ + int i = 0; + ulong hash_value = zend_inline_hash_func(name, name_len+1); + + while (i < op_array->last_var) { + if (op_array->vars[i].hash_value == hash_value && + op_array->vars[i].name_len == name_len && + strcmp(op_array->vars[i].name, name) == 0) { + efree(name); + return i; + } + i++; + } + i = op_array->last_var; + op_array->last_var++; + if (op_array->last_var > op_array->size_var) { + op_array->size_var += 16; /* FIXME */ + op_array->vars = erealloc(op_array->vars, op_array->size_var*sizeof(zend_compiled_variable)); + } + op_array->vars[i].name = name; //estrndup(name, name_len); + op_array->vars[i].name_len = name_len; + op_array->vars[i].hash_value = hash_value; + return i; +} + void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) { @@ -295,13 +321,22 @@ void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *o } } - void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) { zend_op opline; zend_op *opline_ptr; zend_llist *fetch_list_ptr; + if (varname->op_type == IS_CONST && varname->u.constant.type == IS_STRING && + !zend_is_auto_global(varname->u.constant.value.str.val, varname->u.constant.value.str.len TSRMLS_CC) && + !(varname->u.constant.value.str.len == (sizeof("this")-1) && + !memcmp(varname->u.constant.value.str.val, "this", sizeof("this")))) { + result->op_type = IS_CV; + result->u.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len); + result->u.EA.type = 0; + return; + } + if (bp) { opline_ptr = &opline; init_op(opline_ptr TSRMLS_CC); @@ -336,18 +371,56 @@ void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC); } -void zend_do_fetch_static_member(znode *class_znode TSRMLS_DC) +void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC) { zend_llist *fetch_list_ptr; zend_llist_element *le; zend_op *opline_ptr; + zend_op opline; zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); - le = fetch_list_ptr->head; + if (result->op_type == IS_CV) { + init_op(&opline TSRMLS_CC); + + opline.opcode = ZEND_FETCH_W; + opline.result.op_type = IS_VAR; + opline.result.u.EA.type = 0; + opline.result.u.var = get_temporary_variable(CG(active_op_array)); + opline.op1.op_type = IS_CONST; + opline.op1.u.constant.type = IS_STRING; + opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[result->u.var].name); + opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[result->u.var].name_len; + SET_UNUSED(opline.op2); + opline.op2 = *class_znode; + opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER; + *result = opline.result; + + zend_llist_add_element(fetch_list_ptr, &opline); + } else { + le = fetch_list_ptr->head; - opline_ptr = (zend_op *)le->data; - opline_ptr->op2 = *class_znode; - opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER; + opline_ptr = (zend_op *)le->data; + if (opline_ptr->opcode != ZEND_FETCH_W && opline_ptr->op1.op_type == IS_CV) { + init_op(&opline TSRMLS_CC); + opline.opcode = ZEND_FETCH_W; + opline.result.op_type = IS_VAR; + opline.result.u.EA.type = 0; + opline.result.u.var = get_temporary_variable(CG(active_op_array)); + opline.op1.op_type = IS_CONST; + opline.op1.u.constant.type = IS_STRING; + opline.op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[opline_ptr->op1.u.var].name); + opline.op1.u.constant.value.str.len = CG(active_op_array)->vars[opline_ptr->op1.u.var].name_len; + SET_UNUSED(opline.op2); + opline.op2 = *class_znode; + opline.op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER; + opline_ptr->op1 = opline.result; + + zend_llist_prepend_element(fetch_list_ptr, &opline); + } else { + opline_ptr->op2 = *class_znode; + opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER; + } + } } void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) @@ -866,13 +939,6 @@ void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) *result = opline->result; } -static void zend_lowercase_znode_if_const(znode *z) -{ - if (z->op_type == IS_CONST) { - zend_str_tolower(z->u.constant.value.str.val, z->u.constant.value.str.len); - } -} - void zend_do_free(znode *op1 TSRMLS_DC) { if (op1->op_type==IS_TMP_VAR) { @@ -1396,7 +1462,7 @@ void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC) if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) { /* Method call */ op = ZEND_SEND_VAR_NO_REF; - } else if (op == ZEND_SEND_VAL && param->op_type == IS_VAR) { + } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) { op = ZEND_SEND_VAR_NO_REF; } @@ -1404,6 +1470,7 @@ void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC) /* change to passing by reference */ switch (param->op_type) { case IS_VAR: + case IS_CV: op = ZEND_SEND_REF; break; default: @@ -2993,6 +3060,7 @@ void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) last_container = *expr; switch (expr->op_type) { case IS_VAR: + case IS_CV: opline->opcode = ZEND_FETCH_DIM_R; break; case IS_TMP_VAR: @@ -3166,22 +3234,34 @@ void zend_do_unset(znode *variable TSRMLS_DC) zend_check_writable_variable(variable); - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; + if (variable->op_type == IS_CV) { + zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); + opline->opcode = ZEND_UNSET_VAR; + opline->op1.op_type = IS_CONST; + opline->op1.u.constant.type = IS_STRING; + opline->op1.u.constant.value.str.len = CG(active_op_array)->vars[variable->u.var].name_len; + opline->op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[variable->u.var].name); + SET_UNUSED(opline->op2); + opline->op2.u.EA.type = ZEND_FETCH_LOCAL; + SET_UNUSED(opline->result); + } else { + last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; - switch (last_op->opcode) { - case ZEND_FETCH_UNSET: - last_op->opcode = ZEND_UNSET_VAR; - break; - case ZEND_FETCH_DIM_UNSET: - last_op->opcode = ZEND_UNSET_DIM_OBJ; - last_op->extended_value = ZEND_UNSET_DIM; - break; - case ZEND_FETCH_OBJ_UNSET: - last_op->opcode = ZEND_UNSET_DIM_OBJ; - last_op->extended_value = ZEND_UNSET_OBJ; - break; + switch (last_op->opcode) { + case ZEND_FETCH_UNSET: + last_op->opcode = ZEND_UNSET_VAR; + break; + case ZEND_FETCH_DIM_UNSET: + last_op->opcode = ZEND_UNSET_DIM_OBJ; + last_op->extended_value = ZEND_UNSET_DIM; + break; + case ZEND_FETCH_OBJ_UNSET: + last_op->opcode = ZEND_UNSET_DIM_OBJ; + last_op->extended_value = ZEND_UNSET_OBJ; + break; - } + } + } } @@ -3193,18 +3273,29 @@ void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC zend_check_writable_variable(variable); - last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; + if (variable->op_type == IS_CV) { + last_op = get_next_op(CG(active_op_array) TSRMLS_CC); + last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; + last_op->op1.op_type = IS_CONST; + last_op->op1.u.constant.type = IS_STRING; + last_op->op1.u.constant.value.str.len = CG(active_op_array)->vars[variable->u.var].name_len; + last_op->op1.u.constant.value.str.val = estrdup(CG(active_op_array)->vars[variable->u.var].name); + SET_UNUSED(last_op->op2); + last_op->op2.u.EA.type = ZEND_FETCH_LOCAL; + } else { + last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1]; - switch (last_op->opcode) { - case ZEND_FETCH_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; - break; - case ZEND_FETCH_DIM_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; - break; - case ZEND_FETCH_OBJ_IS: - last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; - break; + switch (last_op->opcode) { + case ZEND_FETCH_IS: + last_op->opcode = ZEND_ISSET_ISEMPTY_VAR; + break; + case ZEND_FETCH_DIM_IS: + last_op->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; + break; + case ZEND_FETCH_OBJ_IS: + last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; + break; + } } last_op->result.op_type = IS_TMP_VAR; last_op->extended_value = type; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index b57854a9f8..3fab70f746 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -152,6 +152,12 @@ typedef struct _zend_arg_info { int required_num_args; } zend_arg_info; +typedef struct _zend_compiled_variable { + char *name; + int name_len; + ulong hash_value; +} zend_compiled_variable; + struct _zend_op_array { /* Common elements */ zend_uchar type; @@ -171,6 +177,9 @@ struct _zend_op_array { zend_op *opcodes; zend_uint last, size; + zend_compiled_variable *vars; + int last_var, size_var; + zend_uint T; zend_brk_cont_element *brk_cont_array; @@ -273,8 +282,10 @@ struct _zend_execute_data { zend_op_array *op_array; zval *object; union _temp_variable *Ts; + zval ***CVs; zend_bool original_in_execution; zend_class_entry *calling_scope; + HashTable *symbol_table; struct _zend_execute_data *prev_execute_data; }; @@ -285,6 +296,7 @@ struct _zend_execute_data { #define IS_TMP_VAR (1<<1) #define IS_VAR (1<<2) #define IS_UNUSED (1<<3) /* Unused variable */ +#define IS_CV (1<<4) /* Compiled variable */ #define EXT_TYPE_UNUSED (1<<0) @@ -328,7 +340,7 @@ void zend_do_fetch_global_variable(znode *varname, znode *static_assignment, int void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC); void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC); void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC); -void zend_do_fetch_static_member(znode *class_znode TSRMLS_DC); +void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC); void zend_do_print(znode *result, znode *arg TSRMLS_DC); void zend_do_echo(znode *arg TSRMLS_DC); typedef int (*unary_op_type)(zval *, zval *); diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 612f024e77..9e7c0d2b57 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -38,10 +38,10 @@ typedef int (*incdec_t)(zval *); -#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free TSRMLS_CC) -#define get_zval_ptr_ptr(node, Ts, should_free, type) _get_zval_ptr_ptr(node, Ts, should_free TSRMLS_CC) -#define get_obj_zval_ptr(node, Ts, should_free, type) _get_obj_zval_ptr(node, Ts, should_free TSRMLS_CC) -#define get_obj_zval_ptr_ptr(node, Ts, should_free, type) _get_obj_zval_ptr_ptr(node, Ts, should_free TSRMLS_CC) +#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free, type TSRMLS_CC) +#define get_zval_ptr_ptr(node, Ts, should_free, type) _get_zval_ptr_ptr(node, Ts, should_free, type TSRMLS_CC) +#define get_obj_zval_ptr(node, Ts, should_free, type) _get_obj_zval_ptr(node, Ts, should_free, type TSRMLS_CC) +#define get_obj_zval_ptr_ptr(node, Ts, should_free, type) _get_obj_zval_ptr_ptr(node, Ts, should_free, type TSRMLS_CC) /* Prototypes */ static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC); @@ -126,7 +126,18 @@ static inline void zend_pzval_unlock_free_func(zval *z) /* End of zend_execute_locks.h */ -static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) +#define CV_OF(i) (EG(current_execute_data)->CVs[i]) +#define CV_DEF_OF(i) (EG(active_op_array)->vars[i]) + +static inline void zend_get_cv_address(zend_compiled_variable *cv, zval ***ptr, temp_variable *Ts TSRMLS_DC) +{ + zval *new_zval = &EG(uninitialized_zval); + + new_zval->refcount++; + zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr); +} + +static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) { /* should_free->is_var = 0; */ switch (node->op_type) { @@ -175,14 +186,64 @@ static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, zend_free_op * should_free->var = 0; return NULL; break; + case IS_CV: { + zval ***ptr = &CV_OF(node->u.var); + + should_free->var = 0; + if (!*ptr) { + zend_compiled_variable *cv = &CV_DEF_OF(node->u.var); + if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) { + switch (type) { + case BP_VAR_R: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_IS: + return &EG(uninitialized_zval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_W: + zend_get_cv_address(cv, ptr, Ts TSRMLS_CC); + break; + } + } + } + return **ptr; + break; + } EMPTY_SWITCH_DEFAULT_CASE() } return NULL; } -static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) +static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) { - if (node->op_type==IS_VAR) { + if (node->op_type == IS_CV) { + zval ***ptr = &CV_OF(node->u.var); + + should_free->var = 0; + if (!*ptr) { + zend_compiled_variable *cv = &CV_DEF_OF(node->u.var); + if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) { + switch (type) { + case BP_VAR_R: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_IS: + return &EG(uninitialized_zval_ptr); + break; + case BP_VAR_RW: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_W: + zend_get_cv_address(cv, ptr, Ts TSRMLS_CC); + break; + } + } + } + return *ptr; + } else if (node->op_type == IS_VAR) { if (T(node->u.var).var.ptr_ptr) { PZVAL_UNLOCK(*T(node->u.var).var.ptr_ptr, should_free); return T(node->u.var).var.ptr_ptr; @@ -244,6 +305,33 @@ static inline zval *_get_zval_ptr_var(znode *node, temp_variable *Ts, zend_free_ } } +static inline zval *_get_zval_ptr_cv(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) +{ + zval ***ptr = &CV_OF(node->u.var); + + should_free->var = 0; + if (!*ptr) { + zend_compiled_variable *cv = &CV_DEF_OF(node->u.var); + if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) { + switch (type) { + case BP_VAR_R: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_IS: + return &EG(uninitialized_zval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_W: + zend_get_cv_address(cv, ptr, Ts TSRMLS_CC); + break; + } + } + } + return **ptr; +} + static inline zval *_get_zval_ptr_unused(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) { return NULL; @@ -275,6 +363,33 @@ static inline zval **_get_zval_ptr_ptr_unused(znode *node, temp_variable *Ts, ze return NULL; } +static inline zval **_get_zval_ptr_ptr_cv(znode *node, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) +{ + zval ***ptr = &CV_OF(node->u.var); + + should_free->var = 0; + if (!*ptr) { + zend_compiled_variable *cv = &CV_DEF_OF(node->u.var); + if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) { + switch (type) { + case BP_VAR_R: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_IS: + return &EG(uninitialized_zval_ptr); + break; + case BP_VAR_RW: + zend_error(E_NOTICE, "Undefined variable: %s", cv->name); + /* break missing intentionally */ + case BP_VAR_W: + zend_get_cv_address(cv, ptr, Ts TSRMLS_CC); + break; + } + } + } + return *ptr; +} + static inline zval *_get_obj_zval_ptr_const(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) { return _get_zval_ptr_const(op, Ts, should_free TSRMLS_CC); @@ -290,6 +405,11 @@ static inline zval *_get_obj_zval_ptr_var(znode *op, temp_variable *Ts, zend_fre return _get_zval_ptr_var(op, Ts, should_free TSRMLS_CC); } +static inline zval *_get_obj_zval_ptr_cv(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) +{ + return _get_zval_ptr_cv(op, Ts, should_free, type TSRMLS_CC); +} + static inline zval *_get_obj_zval_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) { if (EG(This)) { @@ -315,6 +435,11 @@ static inline zval **_get_obj_zval_ptr_ptr_var(znode *op, temp_variable *Ts, zen return _get_zval_ptr_ptr_var(op, Ts, should_free TSRMLS_CC); } +static inline zval **_get_obj_zval_ptr_ptr_cv(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) +{ + return _get_zval_ptr_ptr_cv(op, Ts, should_free, type TSRMLS_CC); +} + static inline zval **_get_obj_zval_ptr_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) { if (EG(This)) { @@ -418,7 +543,7 @@ static inline void make_real_object(zval **object_ptr TSRMLS_DC) } } -static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) +static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) { if (op->op_type == IS_UNUSED) { if (EG(This)) { @@ -430,10 +555,10 @@ static inline zval **_get_obj_zval_ptr_ptr(znode *op, temp_variable *Ts, zend_fr zend_error_noreturn(E_ERROR, "Using $this when not in object context"); } } - return _get_zval_ptr_ptr(op, Ts, should_free TSRMLS_CC); + return get_zval_ptr_ptr(op, Ts, should_free, type); } -static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC) +static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC) { if (op->op_type == IS_UNUSED) { if (EG(This)) { @@ -443,7 +568,7 @@ static inline zval *_get_obj_zval_ptr(znode *op, temp_variable *Ts, zend_free_op zend_error_noreturn(E_ERROR, "Using $this when not in object context"); } } - return _get_zval_ptr(op, Ts, should_free TSRMLS_CC); + return get_zval_ptr(op, Ts, should_free, type); } @@ -553,6 +678,7 @@ static inline void zend_assign_to_object(znode *result, zval **object_ptr, znode case IS_CONST: /* already a constant string */ break; + case IS_CV: case IS_VAR: tmp = *property_name; zval_copy_ctor(&tmp); @@ -621,7 +747,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2 if (value->type!=IS_STRING) { tmp = *value; - if (op2->op_type == IS_VAR) { + if (op2->op_type & (IS_VAR|IS_CV)) { zval_copy_ctor(&tmp); } convert_to_string(&tmp); @@ -736,6 +862,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2 variable_ptr->refcount--; if (variable_ptr->refcount==0) { switch (type) { + case IS_CV: case IS_VAR: /* break missing intentionally */ case IS_CONST: @@ -765,6 +892,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2 } } else { /* we need to split */ switch (type) { + case IS_CV: case IS_VAR: /* break missing intentionally */ case IS_CONST: @@ -1182,6 +1310,7 @@ static void zend_fetch_property_address(temp_variable *result, zval **container_ case IS_CONST: /* already a constant string */ break; + case IS_CV: case IS_VAR: tmp = *prop_ptr; zval_copy_ctor(&tmp); @@ -1316,8 +1445,11 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) } else { EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0); } + EX(CVs) = (zval***)do_alloca(sizeof(zval**) * op_array->last_var); + memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var); EX(op_array) = op_array; EX(original_in_execution) = EG(in_execution); + EX(symbol_table) = EG(active_symbol_table); EX(prev_execute_data) = EG(current_execute_data); EG(current_execute_data) = &execute_data; @@ -1436,6 +1568,7 @@ void zend_init_opcodes_handlers() # undef ZEND_VM_NULL_LABEL # undef ZEND_VM_SPEC_LABEL # undef ZEND_VM_SPEC_NULL_LABEL +# undef ZEND_VM_CONTINUE_LABEL # include "zend_vm.h" @@ -1450,9 +1583,12 @@ static void old_execute(zend_op_array *op_array TSRMLS_DC) EX(Ts) = (temp_variable *) do_alloca(sizeof(temp_variable) * op_array->T); } else { EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0); - } + } + EX(CVs) = (zval***)do_alloca(sizeof(zval**) * op_array->last_var); + memset(EX(CVs), 0, sizeof(zval**) * op_array->last_var); EX(op_array) = op_array; EX(original_in_execution) = EG(in_execution); + EX(symbol_table) = EG(active_symbol_table); EX(prev_execute_data) = EG(current_execute_data); EG(current_execute_data) = &execute_data; @@ -1522,9 +1658,17 @@ void zend_vm_set_opcode_handler(zend_op* op) _UNUSED_CODE, /* 5 */ _UNUSED_CODE, /* 6 */ _UNUSED_CODE, /* 7 */ - _UNUSED_CODE /* 8 = IS_UNUSED */ + _UNUSED_CODE, /* 8 = IS_UNUSED */ + _UNUSED_CODE, /* 9 */ + _UNUSED_CODE, /* 10 */ + _UNUSED_CODE, /* 11 */ + _UNUSED_CODE, /* 12 */ + _UNUSED_CODE, /* 13 */ + _UNUSED_CODE, /* 14 */ + _UNUSED_CODE, /* 15 */ + _CV_CODE /* 16 = IS_CV */ }; - op->handler = zend_opcode_handlers[op->opcode * 16 + zend_vm_decode[op->op1.op_type] * 4 + zend_vm_decode[op->op2.op_type]]; + op->handler = zend_opcode_handlers[op->opcode * 25 + zend_vm_decode[op->op1.op_type] * 5 + zend_vm_decode[op->op2.op_type]]; } } diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 45d585f596..481d29e260 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -1343,6 +1343,27 @@ void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC) } } +ZEND_API int delete_global_variable(char *name, int name_len TSRMLS_DC) +{ + zend_execute_data *ex; + + if (zend_symtable_del(&EG(symbol_table), name, name_len+1) == SUCCESS) { + for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) { + if (ex->symbol_table == &EG(symbol_table)) { + int i; + for (i = 0; i < ex->op_array->last_var; i++) { + if (ex->op_array->vars[i].name_len == name_len && + !memcmp(ex->op_array->vars[i].name, name, name_len)) { + ex->CVs[i] = NULL; + break; + } + } + } + } + return SUCCESS; + } + return FAILURE; +} /* * Local variables: diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index afaa8d0cad..7dd066fb0a 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -771,7 +771,7 @@ variable_without_objects: ; static_member: - fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$1 TSRMLS_CC); } + fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects { $$ = $3; zend_do_fetch_static_member(&$$, &$1 TSRMLS_CC); } ; diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 0c47ceaa50..22d03ac8ee 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -67,6 +67,10 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz op_array->opcodes = NULL; op_array_alloc_ops(op_array); + op_array->size_var = 0; /* FIXME:??? */ + op_array->last_var = 0; + op_array->vars = NULL; + op_array->T = 0; op_array->function_name = NULL; @@ -209,6 +213,15 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC) efree(op_array->refcount); + if (op_array->vars) { + i = op_array->last_var; + while (i > 0) { + i--; + efree(op_array->vars[i].name); + } + efree(op_array->vars); + } + while (oplineop1.op_type==IS_CONST) { #if DEBUG_ZEND>2 diff --git a/Zend/zend_vm.h b/Zend/zend_vm.h index cac6b1629b..7f888c917c 100644 --- a/Zend/zend_vm.h +++ b/Zend/zend_vm.h @@ -43,6 +43,7 @@ void zend_vm_set_opcode_handler(zend_op* opcode); #define _TMP_CODE 1 #define _VAR_CODE 2 #define _UNUSED_CODE 3 +#define _CV_CODE 4 #ifndef ZEND_VM_KIND # ifdef __GNUC__ @@ -81,11 +82,19 @@ static const int zend_vm_decode[] = { _UNUSED_CODE, /* 5 */ _UNUSED_CODE, /* 6 */ _UNUSED_CODE, /* 7 */ - _UNUSED_CODE /* 8 = IS_UNUSED */ + _UNUSED_CODE, /* 8 = IS_UNUSED */ + _UNUSED_CODE, /* 9 */ + _UNUSED_CODE, /* 10 */ + _UNUSED_CODE, /* 11 */ + _UNUSED_CODE, /* 12 */ + _UNUSED_CODE, /* 13 */ + _UNUSED_CODE, /* 14 */ + _UNUSED_CODE, /* 15 */ + _CV_CODE /* 16 = IS_CV */ }; # define ZEND_VM_CODE(opcode, op1, op2) \ - opcode * 16 + op1 * 4 + op2 + opcode * 25 + op1 * 5 + op2 # define ZEND_VM_SPEC_OPCODE(opcode, op1, op2) \ ZEND_VM_CODE(opcode, zend_vm_decode[op1], zend_vm_decode[op2]) # ifdef ZEND_VM_HAVE_OLD_EXECUTOR @@ -173,6 +182,7 @@ static const int zend_vm_decode[] = { } # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ + free_alloca(EX(CVs)); \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ free_alloca(EX(Ts)); \ } else { \ @@ -267,6 +277,7 @@ static const int zend_vm_decode[] = { } # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ + free_alloca(EX(CVs)); \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ free_alloca(EX(Ts)); \ } else { \ @@ -358,6 +369,7 @@ static const int zend_vm_decode[] = { } # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ + free_alloca(EX(CVs)); \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ free_alloca(EX(Ts)); \ } else { \ diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 5ce2b3a43a..adbb7178d4 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -9,6 +9,8 @@ # define OP1_TYPE_PREFIX _VAR #elif OP1 == IS_UNUSED # define OP1_TYPE_PREFIX _UNUSED +#elif OP1 == IS_CV +# define OP1_TYPE_PREFIX _CV #elif OP1 == IS_ANY # define OP1_TYPE_PREFIX _ANY #else @@ -24,6 +26,8 @@ # define OP2_TYPE_PREFIX _VAR #elif OP2 == IS_UNUSED # define OP2_TYPE_PREFIX _UNUSED +#elif OP2 == IS_CV +# define OP2_TYPE_PREFIX _CV #elif OP2 == IS_ANY # define OP2_TYPE_PREFIX _ANY #else @@ -187,7 +191,7 @@ /* opcode handlers and helpers */ -#define ZEND_ADD_SPEC() OPDEF(ZEND_ADD, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_ADD_SPEC() OPDEF(ZEND_ADD, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ADD) ZEND_VM_HANDLER(ZEND_ADD) { @@ -203,7 +207,7 @@ ZEND_VM_HANDLER(ZEND_ADD) } #endif -#define ZEND_SUB_SPEC() OPDEF(ZEND_SUB, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_SUB_SPEC() OPDEF(ZEND_SUB, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_SUB) ZEND_VM_HANDLER(ZEND_SUB) { @@ -219,7 +223,7 @@ ZEND_VM_HANDLER(ZEND_SUB) } #endif -#define ZEND_MUL_SPEC() OPDEF(ZEND_MUL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_MUL_SPEC() OPDEF(ZEND_MUL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_MUL) ZEND_VM_HANDLER(ZEND_MUL) { @@ -235,7 +239,7 @@ ZEND_VM_HANDLER(ZEND_MUL) } #endif -#define ZEND_DIV_SPEC() OPDEF(ZEND_DIV, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_DIV_SPEC() OPDEF(ZEND_DIV, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_DIV) ZEND_VM_HANDLER(ZEND_DIV) { @@ -251,7 +255,7 @@ ZEND_VM_HANDLER(ZEND_DIV) } #endif -#define ZEND_MOD_SPEC() OPDEF(ZEND_MOD, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_MOD_SPEC() OPDEF(ZEND_MOD, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_MOD) ZEND_VM_HANDLER(ZEND_MOD) { @@ -267,7 +271,7 @@ ZEND_VM_HANDLER(ZEND_MOD) } #endif -#define ZEND_SL_SPEC() OPDEF(ZEND_SL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_SL_SPEC() OPDEF(ZEND_SL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_SL) ZEND_VM_HANDLER(ZEND_SL) { @@ -283,7 +287,7 @@ ZEND_VM_HANDLER(ZEND_SL) } #endif -#define ZEND_SR_SPEC() OPDEF(ZEND_SR, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_SR_SPEC() OPDEF(ZEND_SR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_SR) ZEND_VM_HANDLER(ZEND_SR) { @@ -299,7 +303,7 @@ ZEND_VM_HANDLER(ZEND_SR) } #endif -#define ZEND_CONCAT_SPEC() OPDEF(ZEND_CONCAT, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_CONCAT_SPEC() OPDEF(ZEND_CONCAT, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_CONCAT) ZEND_VM_HANDLER(ZEND_CONCAT) { @@ -315,7 +319,7 @@ ZEND_VM_HANDLER(ZEND_CONCAT) } #endif -#define ZEND_IS_IDENTICAL_SPEC() OPDEF(ZEND_IS_IDENTICAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_IDENTICAL_SPEC() OPDEF(ZEND_IS_IDENTICAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_IDENTICAL) ZEND_VM_HANDLER(ZEND_IS_IDENTICAL) { @@ -331,7 +335,7 @@ ZEND_VM_HANDLER(ZEND_IS_IDENTICAL) } #endif -#define ZEND_IS_NOT_IDENTICAL_SPEC() OPDEF(ZEND_IS_NOT_IDENTICAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_NOT_IDENTICAL_SPEC() OPDEF(ZEND_IS_NOT_IDENTICAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_NOT_IDENTICAL) ZEND_VM_HANDLER(ZEND_IS_NOT_IDENTICAL) { @@ -347,7 +351,7 @@ ZEND_VM_HANDLER(ZEND_IS_NOT_IDENTICAL) } #endif -#define ZEND_IS_EQUAL_SPEC() OPDEF(ZEND_IS_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_EQUAL_SPEC() OPDEF(ZEND_IS_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_EQUAL) ZEND_VM_HANDLER(ZEND_IS_EQUAL) { @@ -363,7 +367,7 @@ ZEND_VM_HANDLER(ZEND_IS_EQUAL) } #endif -#define ZEND_IS_NOT_EQUAL_SPEC() OPDEF(ZEND_IS_NOT_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_NOT_EQUAL_SPEC() OPDEF(ZEND_IS_NOT_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_NOT_EQUAL) ZEND_VM_HANDLER(ZEND_IS_NOT_EQUAL) { @@ -379,7 +383,7 @@ ZEND_VM_HANDLER(ZEND_IS_NOT_EQUAL) } #endif -#define ZEND_IS_SMALLER_SPEC() OPDEF(ZEND_IS_SMALLER, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_SMALLER_SPEC() OPDEF(ZEND_IS_SMALLER, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_SMALLER) ZEND_VM_HANDLER(ZEND_IS_SMALLER) { @@ -395,7 +399,7 @@ ZEND_VM_HANDLER(ZEND_IS_SMALLER) } #endif -#define ZEND_IS_SMALLER_OR_EQUAL_SPEC() OPDEF(ZEND_IS_SMALLER_OR_EQUAL, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_IS_SMALLER_OR_EQUAL_SPEC() OPDEF(ZEND_IS_SMALLER_OR_EQUAL, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_IS_SMALLER_OR_EQUAL) ZEND_VM_HANDLER(ZEND_IS_SMALLER_OR_EQUAL) { @@ -411,7 +415,7 @@ ZEND_VM_HANDLER(ZEND_IS_SMALLER_OR_EQUAL) } #endif -#define ZEND_BW_OR_SPEC() OPDEF(ZEND_BW_OR, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_BW_OR_SPEC() OPDEF(ZEND_BW_OR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_BW_OR) ZEND_VM_HANDLER(ZEND_BW_OR) { @@ -427,7 +431,7 @@ ZEND_VM_HANDLER(ZEND_BW_OR) } #endif -#define ZEND_BW_AND_SPEC() OPDEF(ZEND_BW_AND, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_BW_AND_SPEC() OPDEF(ZEND_BW_AND, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_BW_AND) ZEND_VM_HANDLER(ZEND_BW_AND) { @@ -443,7 +447,7 @@ ZEND_VM_HANDLER(ZEND_BW_AND) } #endif -#define ZEND_BW_XOR_SPEC() OPDEF(ZEND_BW_XOR, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_BW_XOR_SPEC() OPDEF(ZEND_BW_XOR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_BW_XOR) ZEND_VM_HANDLER(ZEND_BW_XOR) { @@ -459,7 +463,7 @@ ZEND_VM_HANDLER(ZEND_BW_XOR) } #endif -#define ZEND_BOOL_XOR_SPEC() OPDEF(ZEND_BOOL_XOR, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_BOOL_XOR_SPEC() OPDEF(ZEND_BOOL_XOR, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_BOOL_XOR) ZEND_VM_HANDLER(ZEND_BOOL_XOR) { @@ -475,7 +479,7 @@ ZEND_VM_HANDLER(ZEND_BOOL_XOR) } #endif -#define ZEND_BW_NOT_SPEC() OPDEF(ZEND_BW_NOT, M_CONST_TMP_VAR, M_ANY) +#define ZEND_BW_NOT_SPEC() OPDEF(ZEND_BW_NOT, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_BW_NOT) ZEND_VM_HANDLER(ZEND_BW_NOT) { @@ -489,7 +493,7 @@ ZEND_VM_HANDLER(ZEND_BW_NOT) } #endif -#define ZEND_BOOL_NOT_SPEC() OPDEF(ZEND_BOOL_NOT, M_CONST_TMP_VAR, M_ANY) +#define ZEND_BOOL_NOT_SPEC() OPDEF(ZEND_BOOL_NOT, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_BOOL_NOT) ZEND_VM_HANDLER(ZEND_BOOL_NOT) { @@ -503,7 +507,7 @@ ZEND_VM_HANDLER(ZEND_BOOL_NOT) } #endif -#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR) +#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC)) { zend_op *opline = EX(opline); @@ -537,6 +541,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, int (*binary_op)(zval *resul case IS_CONST: /* already a constant string */ break; + case IS_CV: case IS_VAR: tmp = *property; zval_copy_ctor(&tmp); @@ -631,7 +636,9 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, int (*binary_op)(zval *result, z case ZEND_ASSIGN_DIM: { zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W); - (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */ + if(OP1_TYPE != IS_CV) { + (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */ + } if ((*object_ptr)->type == IS_OBJECT) { ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op); @@ -700,7 +707,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, int (*binary_op)(zval *result, z } #endif -#define ZEND_ASSIGN_ADD_SPEC() OPDEF(ZEND_ASSIGN_ADD, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_ADD_SPEC() OPDEF(ZEND_ASSIGN_ADD, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_ADD) ZEND_VM_HANDLER(ZEND_ASSIGN_ADD) { @@ -708,7 +715,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_ADD) } #endif -#define ZEND_ASSIGN_SUB_SPEC() OPDEF(ZEND_ASSIGN_SUB, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_SUB_SPEC() OPDEF(ZEND_ASSIGN_SUB, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_SUB) ZEND_VM_HANDLER(ZEND_ASSIGN_SUB) { @@ -716,7 +723,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_SUB) } #endif -#define ZEND_ASSIGN_MUL_SPEC() OPDEF(ZEND_ASSIGN_MUL, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_MUL_SPEC() OPDEF(ZEND_ASSIGN_MUL, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_MUL) ZEND_VM_HANDLER(ZEND_ASSIGN_MUL) { @@ -724,7 +731,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_MUL) } #endif -#define ZEND_ASSIGN_DIV_SPEC() OPDEF(ZEND_ASSIGN_DIV, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_DIV_SPEC() OPDEF(ZEND_ASSIGN_DIV, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_DIV) ZEND_VM_HANDLER(ZEND_ASSIGN_DIV) { @@ -732,7 +739,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_DIV) } #endif -#define ZEND_ASSIGN_MOD_SPEC() OPDEF(ZEND_ASSIGN_MOD, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_MOD_SPEC() OPDEF(ZEND_ASSIGN_MOD, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_MOD) ZEND_VM_HANDLER(ZEND_ASSIGN_MOD) { @@ -740,7 +747,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_MOD) } #endif -#define ZEND_ASSIGN_SL_SPEC() OPDEF(ZEND_ASSIGN_SL, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_SL_SPEC() OPDEF(ZEND_ASSIGN_SL, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_SL) ZEND_VM_HANDLER(ZEND_ASSIGN_SL) { @@ -748,7 +755,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_SL) } #endif -#define ZEND_ASSIGN_SR_SPEC() OPDEF(ZEND_ASSIGN_SR, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_SR_SPEC() OPDEF(ZEND_ASSIGN_SR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_SR) ZEND_VM_HANDLER(ZEND_ASSIGN_SR) { @@ -756,7 +763,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_SR) } #endif -#define ZEND_ASSIGN_CONCAT_SPEC() OPDEF(ZEND_ASSIGN_CONCAT, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_CONCAT_SPEC() OPDEF(ZEND_ASSIGN_CONCAT, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_CONCAT) ZEND_VM_HANDLER(ZEND_ASSIGN_CONCAT) { @@ -764,7 +771,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_CONCAT) } #endif -#define ZEND_ASSIGN_BW_OR_SPEC() OPDEF(ZEND_ASSIGN_BW_OR, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_BW_OR_SPEC() OPDEF(ZEND_ASSIGN_BW_OR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_BW_OR) ZEND_VM_HANDLER(ZEND_ASSIGN_BW_OR) { @@ -772,7 +779,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_BW_OR) } #endif -#define ZEND_ASSIGN_BW_AND_SPEC() OPDEF(ZEND_ASSIGN_BW_AND, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_BW_AND_SPEC() OPDEF(ZEND_ASSIGN_BW_AND, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_BW_AND) ZEND_VM_HANDLER(ZEND_ASSIGN_BW_AND) { @@ -780,7 +787,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_BW_AND) } #endif -#define ZEND_ASSIGN_BW_XOR_SPEC() OPDEF(ZEND_ASSIGN_BW_XOR, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_BW_XOR_SPEC() OPDEF(ZEND_ASSIGN_BW_XOR, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_BW_XOR) ZEND_VM_HANDLER(ZEND_ASSIGN_BW_XOR) { @@ -788,7 +795,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_BW_XOR) } #endif -#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR) +#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, incdec_t incdec_op) { zend_op *opline = EX(opline); @@ -856,7 +863,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, incdec_t incdec_op) } #endif -#define ZEND_PRE_INC_OBJ_SPEC() OPDEF(ZEND_PRE_INC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_PRE_INC_OBJ_SPEC() OPDEF(ZEND_PRE_INC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_PRE_INC_OBJ) ZEND_VM_HANDLER(ZEND_PRE_INC_OBJ) { @@ -864,7 +871,7 @@ ZEND_VM_HANDLER(ZEND_PRE_INC_OBJ) } #endif -#define ZEND_PRE_DEC_OBJ_SPEC() OPDEF(ZEND_PRE_DEC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_PRE_DEC_OBJ_SPEC() OPDEF(ZEND_PRE_DEC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_PRE_DEC_OBJ) ZEND_VM_HANDLER(ZEND_PRE_DEC_OBJ) { @@ -872,7 +879,7 @@ ZEND_VM_HANDLER(ZEND_PRE_DEC_OBJ) } #endif -#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR) +#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, incdec_t incdec_op) { zend_op *opline = EX(opline); @@ -936,7 +943,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, incdec_t incdec_op) } #endif -#define ZEND_POST_INC_OBJ_SPEC() OPDEF(ZEND_POST_INC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_POST_INC_OBJ_SPEC() OPDEF(ZEND_POST_INC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_POST_INC_OBJ) ZEND_VM_HANDLER(ZEND_POST_INC_OBJ) { @@ -944,7 +951,7 @@ ZEND_VM_HANDLER(ZEND_POST_INC_OBJ) } #endif -#define ZEND_POST_DEC_OBJ_SPEC() OPDEF(ZEND_POST_DEC_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_POST_DEC_OBJ_SPEC() OPDEF(ZEND_POST_DEC_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_POST_DEC_OBJ) ZEND_VM_HANDLER(ZEND_POST_DEC_OBJ) { @@ -952,7 +959,7 @@ ZEND_VM_HANDLER(ZEND_POST_DEC_OBJ) } #endif -#define ZEND_PRE_INC_SPEC() OPDEF(ZEND_PRE_INC, M_VAR, M_ANY) +#define ZEND_PRE_INC_SPEC() OPDEF(ZEND_PRE_INC, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_PRE_INC) ZEND_VM_HANDLER(ZEND_PRE_INC) { @@ -998,7 +1005,7 @@ ZEND_VM_HANDLER(ZEND_PRE_INC) } #endif -#define ZEND_PRE_DEC_SPEC() OPDEF(ZEND_PRE_DEC, M_VAR, M_ANY) +#define ZEND_PRE_DEC_SPEC() OPDEF(ZEND_PRE_DEC, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_PRE_DEC) ZEND_VM_HANDLER(ZEND_PRE_DEC) { @@ -1044,7 +1051,7 @@ ZEND_VM_HANDLER(ZEND_PRE_DEC) } #endif -#define ZEND_POST_INC_SPEC() OPDEF(ZEND_POST_INC, M_VAR, M_ANY) +#define ZEND_POST_INC_SPEC() OPDEF(ZEND_POST_INC, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_POST_INC) ZEND_VM_HANDLER(ZEND_POST_INC) { @@ -1087,7 +1094,7 @@ ZEND_VM_HANDLER(ZEND_POST_INC) } #endif -#define ZEND_POST_DEC_SPEC() OPDEF(ZEND_POST_DEC, M_VAR, M_ANY) +#define ZEND_POST_DEC_SPEC() OPDEF(ZEND_POST_DEC, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_POST_DEC) ZEND_VM_HANDLER(ZEND_POST_DEC) { @@ -1130,7 +1137,7 @@ ZEND_VM_HANDLER(ZEND_POST_DEC) } #endif -#define ZEND_ECHO_SPEC() OPDEF(ZEND_ECHO, M_CONST_TMP_VAR, M_ANY) +#define ZEND_ECHO_SPEC() OPDEF(ZEND_ECHO, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_ECHO) ZEND_VM_HANDLER_EX(ZEND_ECHO) { @@ -1152,7 +1159,7 @@ ZEND_VM_HANDLER_EX(ZEND_ECHO) } #endif -#define ZEND_PRINT_SPEC() OPDEF(ZEND_PRINT, M_CONST_TMP_VAR, M_ANY) +#define ZEND_PRINT_SPEC() OPDEF(ZEND_PRINT, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_PRINT) ZEND_VM_HANDLER(ZEND_PRINT) { @@ -1165,7 +1172,7 @@ ZEND_VM_HANDLER(ZEND_PRINT) } #endif -#if OP1_OP2_MASK(M_CONST_TMP_VAR, M_ANY) +#if OP1_OP2_MASK(M_CONST_TMP_VAR_CV, M_ANY) ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, int type) { zend_op *opline = EX(opline); @@ -1256,7 +1263,7 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, int type) } #endif -#define ZEND_FETCH_R_SPEC() OPDEF(ZEND_FETCH_R, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_R_SPEC() OPDEF(ZEND_FETCH_R, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_R) ZEND_VM_HANDLER(ZEND_FETCH_R) { @@ -1264,7 +1271,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_R) } #endif -#define ZEND_FETCH_W_SPEC() OPDEF(ZEND_FETCH_W, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_W_SPEC() OPDEF(ZEND_FETCH_W, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_W) ZEND_VM_HANDLER(ZEND_FETCH_W) { @@ -1272,7 +1279,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_W) } #endif -#define ZEND_FETCH_RW_SPEC() OPDEF(ZEND_FETCH_RW, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_RW_SPEC() OPDEF(ZEND_FETCH_RW, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_RW) ZEND_VM_HANDLER(ZEND_FETCH_RW) { @@ -1280,7 +1287,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_RW) } #endif -#define ZEND_FETCH_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_FUNC_ARG, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_FUNC_ARG, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_FUNC_ARG) ZEND_VM_HANDLER(ZEND_FETCH_FUNC_ARG) { @@ -1289,7 +1296,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_FUNC_ARG) } #endif -#define ZEND_FETCH_UNSET_SPEC() OPDEF(ZEND_FETCH_UNSET, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_UNSET_SPEC() OPDEF(ZEND_FETCH_UNSET, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_UNSET) ZEND_VM_HANDLER(ZEND_FETCH_UNSET) { @@ -1297,7 +1304,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_UNSET) } #endif -#define ZEND_FETCH_IS_SPEC() OPDEF(ZEND_FETCH_IS, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FETCH_IS_SPEC() OPDEF(ZEND_FETCH_IS, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FETCH_IS) ZEND_VM_HANDLER(ZEND_FETCH_IS) { @@ -1305,14 +1312,14 @@ ZEND_VM_HANDLER(ZEND_FETCH_IS) } #endif -#define ZEND_FETCH_DIM_R_SPEC() OPDEF(ZEND_FETCH_DIM_R, M_VAR, M_CONST_TMP_VAR) +#define ZEND_FETCH_DIM_R_SPEC() OPDEF(ZEND_FETCH_DIM_R, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_DIM_R) ZEND_VM_HANDLER(ZEND_FETCH_DIM_R) { zend_op *opline = EX(opline); zend_free_op free_op1, free_op2; - if (opline->extended_value == ZEND_FETCH_ADD_LOCK) { + if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) { PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr); } zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_R), GET_OP2_ZVAL_PTR(BP_VAR_R), BP_VAR_R TSRMLS_CC); @@ -1322,7 +1329,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_R) } #endif -#define ZEND_FETCH_DIM_W_SPEC() OPDEF(ZEND_FETCH_DIM_W, M_VAR, M_CONST_TMP_VAR_UNUSED) +#define ZEND_FETCH_DIM_W_SPEC() OPDEF(ZEND_FETCH_DIM_W, M_VAR_CV, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_FETCH_DIM_W) ZEND_VM_HANDLER(ZEND_FETCH_DIM_W) { @@ -1336,7 +1343,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_W) } #endif -#define ZEND_FETCH_DIM_RW_SPEC() OPDEF(ZEND_FETCH_DIM_RW, M_VAR, M_CONST_TMP_VAR) +#define ZEND_FETCH_DIM_RW_SPEC() OPDEF(ZEND_FETCH_DIM_RW, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_DIM_RW) ZEND_VM_HANDLER(ZEND_FETCH_DIM_RW) { @@ -1350,7 +1357,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_RW) } #endif -#define ZEND_FETCH_DIM_IS_SPEC() OPDEF(ZEND_FETCH_DIM_IS, M_VAR, M_CONST_TMP_VAR) +#define ZEND_FETCH_DIM_IS_SPEC() OPDEF(ZEND_FETCH_DIM_IS, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_DIM_IS) ZEND_VM_HANDLER(ZEND_FETCH_DIM_IS) { @@ -1364,7 +1371,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_IS) } #endif -#define ZEND_FETCH_DIM_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_DIM_FUNC_ARG, M_VAR, M_CONST_TMP_VAR) +#define ZEND_FETCH_DIM_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_DIM_FUNC_ARG, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_DIM_FUNC_ARG) ZEND_VM_HANDLER(ZEND_FETCH_DIM_FUNC_ARG) { @@ -1379,7 +1386,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_FUNC_ARG) } #endif -#define ZEND_FETCH_DIM_UNSET_SPEC() OPDEF(ZEND_FETCH_DIM_UNSET, M_VAR, M_CONST_TMP_VAR) +#define ZEND_FETCH_DIM_UNSET_SPEC() OPDEF(ZEND_FETCH_DIM_UNSET, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_DIM_UNSET) ZEND_VM_HANDLER(ZEND_FETCH_DIM_UNSET) { @@ -1410,7 +1417,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_UNSET) } #endif -#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR) +#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, int type) { zend_op *opline = EX(opline); @@ -1446,6 +1453,7 @@ ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, int type) case IS_CONST: /* already a constant string */ break; + case IS_CV: case IS_VAR: tmp = *offset; zval_copy_ctor(&tmp); @@ -1478,7 +1486,7 @@ ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, int type) } #endif -#define ZEND_FETCH_OBJ_R_SPEC() OPDEF(ZEND_FETCH_OBJ_R, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_R_SPEC() OPDEF(ZEND_FETCH_OBJ_R, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_R) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_R) { @@ -1486,14 +1494,14 @@ ZEND_VM_HANDLER(ZEND_FETCH_OBJ_R) } #endif -#define ZEND_FETCH_OBJ_W_SPEC() OPDEF(ZEND_FETCH_OBJ_W, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_W_SPEC() OPDEF(ZEND_FETCH_OBJ_W, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_W) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_W) { zend_op *opline = EX(opline); zend_free_op free_op1, free_op2; - if (opline->extended_value == ZEND_FETCH_ADD_LOCK) { + if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) { PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr); EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr; } @@ -1504,7 +1512,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_OBJ_W) } #endif -#define ZEND_FETCH_OBJ_RW_SPEC() OPDEF(ZEND_FETCH_OBJ_RW, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_RW_SPEC() OPDEF(ZEND_FETCH_OBJ_RW, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_RW) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_RW) { @@ -1518,7 +1526,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_OBJ_RW) } #endif -#define ZEND_FETCH_OBJ_IS_SPEC() OPDEF(ZEND_FETCH_OBJ_IS, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_IS_SPEC() OPDEF(ZEND_FETCH_OBJ_IS, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_IS) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_IS) { @@ -1526,7 +1534,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_OBJ_IS) } #endif -#define ZEND_FETCH_OBJ_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_OBJ_FUNC_ARG, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_FUNC_ARG_SPEC() OPDEF(ZEND_FETCH_OBJ_FUNC_ARG, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_FUNC_ARG) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_FUNC_ARG) { @@ -1546,7 +1554,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_OBJ_FUNC_ARG) } #endif -#define ZEND_FETCH_OBJ_UNSET_SPEC() OPDEF(ZEND_FETCH_OBJ_UNSET, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_FETCH_OBJ_UNSET_SPEC() OPDEF(ZEND_FETCH_OBJ_UNSET, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_FETCH_OBJ_UNSET) ZEND_VM_HANDLER(ZEND_FETCH_OBJ_UNSET) { @@ -1593,7 +1601,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_DIM_TMP_VAR) } #endif -#define ZEND_ASSIGN_OBJ_SPEC() OPDEF(ZEND_ASSIGN_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_OBJ_SPEC() OPDEF(ZEND_ASSIGN_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_OBJ) ZEND_VM_HANDLER(ZEND_ASSIGN_OBJ) { @@ -1610,7 +1618,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_OBJ) } #endif -#define ZEND_ASSIGN_DIM_SPEC() OPDEF(ZEND_ASSIGN_DIM, M_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED) +#define ZEND_ASSIGN_DIM_SPEC() OPDEF(ZEND_ASSIGN_DIM, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_ASSIGN_DIM) ZEND_VM_HANDLER(ZEND_ASSIGN_DIM) { @@ -1619,7 +1627,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_DIM) zend_free_op free_op1; zval **object_ptr; - if (EX_T(opline->op1.u.var).var.ptr_ptr) { + if (OP1_TYPE == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) { /* not an array offset */ object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W); } else { @@ -1632,7 +1640,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_DIM) zend_free_op free_op2, free_op_data1; zval *value; - if (object_ptr) { + if (object_ptr && OP1_TYPE != IS_CV) { (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */ } zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_W), GET_OP2_ZVAL_PTR(BP_VAR_R), BP_VAR_W TSRMLS_CC); @@ -1649,7 +1657,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN_DIM) } #endif -#define ZEND_ASSIGN_SPEC() OPDEF(ZEND_ASSIGN, M_VAR, M_CONST_TMP_VAR) +#define ZEND_ASSIGN_SPEC() OPDEF(ZEND_ASSIGN, M_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ASSIGN) ZEND_VM_HANDLER(ZEND_ASSIGN) { @@ -1665,7 +1673,7 @@ ZEND_VM_HANDLER(ZEND_ASSIGN) } #endif -#define ZEND_ASSIGN_REF_SPEC() OPDEF(ZEND_ASSIGN_REF, M_VAR, M_VAR) +#define ZEND_ASSIGN_REF_SPEC() OPDEF(ZEND_ASSIGN_REF, M_VAR_CV, M_VAR_CV) #if HAVE_OP(ZEND_ASSIGN_REF) ZEND_VM_HANDLER(ZEND_ASSIGN_REF) { @@ -1701,7 +1709,7 @@ ZEND_VM_HANDLER(ZEND_JMP) } #endif -#define ZEND_JMPZ_SPEC() OPDEF(ZEND_JMPZ, M_CONST_TMP_VAR, M_ANY) +#define ZEND_JMPZ_SPEC() OPDEF(ZEND_JMPZ, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMPZ) ZEND_VM_HANDLER(ZEND_JMPZ) { @@ -1722,7 +1730,7 @@ ZEND_VM_HANDLER(ZEND_JMPZ) } #endif -#define ZEND_JMPNZ_SPEC() OPDEF(ZEND_JMPNZ, M_CONST_TMP_VAR, M_ANY) +#define ZEND_JMPNZ_SPEC() OPDEF(ZEND_JMPNZ, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMPNZ) ZEND_VM_HANDLER(ZEND_JMPNZ) { @@ -1743,7 +1751,7 @@ ZEND_VM_HANDLER(ZEND_JMPNZ) } #endif -#define ZEND_JMPZNZ_SPEC() OPDEF(ZEND_JMPZNZ, M_CONST_TMP_VAR, M_ANY) +#define ZEND_JMPZNZ_SPEC() OPDEF(ZEND_JMPZNZ, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMPZNZ) ZEND_VM_HANDLER(ZEND_JMPZNZ) { @@ -1769,7 +1777,7 @@ ZEND_VM_HANDLER(ZEND_JMPZNZ) } #endif -#define ZEND_JMPZ_EX_SPEC() OPDEF(ZEND_JMPZ_EX, M_CONST_TMP_VAR, M_ANY) +#define ZEND_JMPZ_EX_SPEC() OPDEF(ZEND_JMPZ_EX, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMPZ_EX) ZEND_VM_HANDLER(ZEND_JMPZ_EX) { @@ -1791,7 +1799,7 @@ ZEND_VM_HANDLER(ZEND_JMPZ_EX) } #endif -#define ZEND_JMPNZ_EX_SPEC() OPDEF(ZEND_JMPNZ_EX, M_CONST_TMP_VAR, M_ANY) +#define ZEND_JMPNZ_EX_SPEC() OPDEF(ZEND_JMPNZ_EX, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMPNZ_EX) ZEND_VM_HANDLER(ZEND_JMPNZ_EX) { @@ -1868,7 +1876,7 @@ ZEND_VM_HANDLER(ZEND_ADD_STRING) } #endif -#define ZEND_ADD_VAR_SPEC() OPDEF(ZEND_ADD_VAR, M_TMP, M_TMP_VAR) +#define ZEND_ADD_VAR_SPEC() OPDEF(ZEND_ADD_VAR, M_TMP, M_TMP_VAR_CV) #if HAVE_OP(ZEND_ADD_VAR) ZEND_VM_HANDLER(ZEND_ADD_VAR) { @@ -1900,7 +1908,7 @@ ZEND_VM_HANDLER(ZEND_ADD_VAR) } #endif -#define ZEND_FETCH_CLASS_SPEC() OPDEF(ZEND_FETCH_CLASS, M_ANY, M_CONST_TMP_VAR_UNUSED) +#define ZEND_FETCH_CLASS_SPEC() OPDEF(ZEND_FETCH_CLASS, M_ANY, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_FETCH_CLASS) ZEND_VM_HANDLER(ZEND_FETCH_CLASS) { @@ -1933,7 +1941,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_CLASS) } #endif -#define ZEND_INIT_CTOR_CALL_SPEC() OPDEF(ZEND_INIT_CTOR_CALL, M_TMP_VAR, M_ANY) +#define ZEND_INIT_CTOR_CALL_SPEC() OPDEF(ZEND_INIT_CTOR_CALL, M_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_INIT_CTOR_CALL) ZEND_VM_HANDLER(ZEND_INIT_CTOR_CALL) { @@ -1965,7 +1973,7 @@ ZEND_VM_HANDLER(ZEND_INIT_CTOR_CALL) } #endif -#define ZEND_INIT_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_METHOD_CALL, M_TMP_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_INIT_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_METHOD_CALL, M_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_INIT_METHOD_CALL) ZEND_VM_HANDLER(ZEND_INIT_METHOD_CALL) { @@ -2031,7 +2039,7 @@ ZEND_VM_HANDLER(ZEND_INIT_METHOD_CALL) } #endif -#define ZEND_INIT_STATIC_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_STATIC_METHOD_CALL, M_ANY, M_CONST_TMP_VAR_UNUSED) +#define ZEND_INIT_STATIC_METHOD_CALL_SPEC() OPDEF(ZEND_INIT_STATIC_METHOD_CALL, M_ANY, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_INIT_STATIC_METHOD_CALL) ZEND_VM_HANDLER(ZEND_INIT_STATIC_METHOD_CALL) { @@ -2088,7 +2096,7 @@ ZEND_VM_HANDLER(ZEND_INIT_STATIC_METHOD_CALL) } #endif -#define ZEND_INIT_FCALL_BY_NAME_SPEC() OPDEF(ZEND_INIT_FCALL_BY_NAME, M_ANY, M_CONST_TMP_VAR) +#define ZEND_INIT_FCALL_BY_NAME_SPEC() OPDEF(ZEND_INIT_FCALL_BY_NAME, M_ANY, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_INIT_FCALL_BY_NAME) ZEND_VM_HANDLER(ZEND_INIT_FCALL_BY_NAME) { @@ -2344,7 +2352,7 @@ ZEND_VM_HANDLER(ZEND_DO_FCALL) } #endif -#define ZEND_RETURN_SPEC() OPDEF(ZEND_RETURN, M_CONST_TMP_VAR, M_ANY) +#define ZEND_RETURN_SPEC() OPDEF(ZEND_RETURN, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_RETURN) ZEND_VM_HANDLER(ZEND_RETURN) { @@ -2421,7 +2429,7 @@ ZEND_VM_C_LABEL(return_by_value): } #endif -#define ZEND_THROW_SPEC() OPDEF(ZEND_THROW, M_VAR, M_ANY) +#define ZEND_THROW_SPEC() OPDEF(ZEND_THROW, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_THROW) ZEND_VM_HANDLER(ZEND_THROW) { @@ -2479,7 +2487,7 @@ ZEND_VM_HANDLER(ZEND_CATCH) } #endif -#define ZEND_SEND_VAL_SPEC() OPDEF(ZEND_SEND_VAL, M_CONST_TMP_VAR, M_ANY) +#define ZEND_SEND_VAL_SPEC() OPDEF(ZEND_SEND_VAL, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_SEND_VAL) ZEND_VM_HANDLER(ZEND_SEND_VAL) { @@ -2507,7 +2515,7 @@ ZEND_VM_HANDLER(ZEND_SEND_VAL) } #endif -#if OP1_OP2_MASK(M_VAR, M_ANY) +#if OP1_OP2_MASK(M_VAR_CV, M_ANY) ZEND_VM_HELPER(zend_send_by_var_helper) { zend_op *opline = EX(opline); @@ -2536,7 +2544,7 @@ ZEND_VM_HELPER(zend_send_by_var_helper) } #endif -#define ZEND_SEND_VAR_NO_REF_SPEC() OPDEF(ZEND_SEND_VAR_NO_REF, M_VAR, M_ANY) +#define ZEND_SEND_VAR_NO_REF_SPEC() OPDEF(ZEND_SEND_VAR_NO_REF, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_SEND_VAR_NO_REF) ZEND_VM_HANDLER(ZEND_SEND_VAR_NO_REF) { @@ -2566,7 +2574,7 @@ ZEND_VM_HANDLER(ZEND_SEND_VAR_NO_REF) } #endif -#define ZEND_SEND_REF_SPEC() OPDEF(ZEND_SEND_REF, M_VAR, M_ANY) +#define ZEND_SEND_REF_SPEC() OPDEF(ZEND_SEND_REF, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_SEND_REF) ZEND_VM_HANDLER_EX(ZEND_SEND_REF) { @@ -2590,7 +2598,7 @@ ZEND_VM_HANDLER_EX(ZEND_SEND_REF) } #endif -#define ZEND_SEND_VAR_SPEC() OPDEF(ZEND_SEND_VAR, M_VAR, M_ANY) +#define ZEND_SEND_VAR_SPEC() OPDEF(ZEND_SEND_VAR, M_VAR_CV, M_ANY) #if HAVE_OP(ZEND_SEND_VAR) ZEND_VM_HANDLER(ZEND_SEND_VAR) { @@ -2688,7 +2696,7 @@ ZEND_VM_HANDLER(ZEND_RECV_INIT) } #endif -#define ZEND_BOOL_SPEC() OPDEF(ZEND_BOOL, M_CONST_TMP_VAR, M_ANY) +#define ZEND_BOOL_SPEC() OPDEF(ZEND_BOOL, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_BOOL) ZEND_VM_HANDLER(ZEND_BOOL) { @@ -2704,7 +2712,7 @@ ZEND_VM_HANDLER(ZEND_BOOL) } #endif -#define ZEND_BRK_SPEC() OPDEF(ZEND_BRK, M_ANY, M_CONST_TMP_VAR) +#define ZEND_BRK_SPEC() OPDEF(ZEND_BRK, M_ANY, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_BRK) ZEND_VM_HANDLER(ZEND_BRK) { @@ -2720,7 +2728,7 @@ ZEND_VM_HANDLER(ZEND_BRK) } #endif -#define ZEND_CONT_SPEC() OPDEF(ZEND_CONT, M_ANY, M_CONST_TMP_VAR) +#define ZEND_CONT_SPEC() OPDEF(ZEND_CONT, M_ANY, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_CONT) ZEND_VM_HANDLER(ZEND_CONT) { @@ -2736,7 +2744,7 @@ ZEND_VM_HANDLER(ZEND_CONT) } #endif -#define ZEND_CASE_SPEC() OPDEF(ZEND_CASE, M_CONST_TMP_VAR, M_CONST_TMP_VAR) +#define ZEND_CASE_SPEC() OPDEF(ZEND_CASE, M_CONST_TMP_VAR_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_CASE) ZEND_VM_HANDLER(ZEND_CASE) { @@ -2806,7 +2814,7 @@ ZEND_VM_HANDLER(ZEND_NEW) } #endif -#define ZEND_CLONE_SPEC() OPDEF(ZEND_CLONE, M_CONST_TMP_VAR_UNUSED, M_ANY) +#define ZEND_CLONE_SPEC() OPDEF(ZEND_CLONE, M_CONST_TMP_VAR_UNUSED_CV, M_ANY) #if HAVE_OP(ZEND_CLONE) ZEND_VM_HANDLER(ZEND_CLONE) { @@ -2909,7 +2917,7 @@ ZEND_VM_HANDLER(ZEND_FETCH_CONSTANT) } #endif -#if OP1_OP2_MASK(M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED) +#if OP1_OP2_MASK(M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV) ZEND_VM_HELPER(zend_init_add_array_helper) { zend_op *opline = EX(opline); @@ -2919,7 +2927,7 @@ ZEND_VM_HELPER(zend_init_add_array_helper) zval *offset=GET_OP2_ZVAL_PTR(BP_VAR_R); if (opline->extended_value) { - expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_R); + expr_ptr_ptr=GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); expr_ptr = *expr_ptr_ptr; } else { expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R); @@ -2987,7 +2995,7 @@ ZEND_VM_HELPER(zend_init_add_array_helper) } #endif -#define ZEND_INIT_ARRAY_SPEC() OPDEF(ZEND_INIT_ARRAY, M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED) +#define ZEND_INIT_ARRAY_SPEC() OPDEF(ZEND_INIT_ARRAY, M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_INIT_ARRAY) ZEND_VM_HANDLER(ZEND_INIT_ARRAY) { @@ -2995,7 +3003,7 @@ ZEND_VM_HANDLER(ZEND_INIT_ARRAY) } #endif -#define ZEND_ADD_ARRAY_ELEMENT_SPEC() OPDEF(ZEND_ADD_ARRAY_ELEMENT, M_CONST_TMP_VAR_UNUSED, M_CONST_TMP_VAR_UNUSED) +#define ZEND_ADD_ARRAY_ELEMENT_SPEC() OPDEF(ZEND_ADD_ARRAY_ELEMENT, M_CONST_TMP_VAR_UNUSED_CV, M_CONST_TMP_VAR_UNUSED_CV) #if HAVE_OP(ZEND_ADD_ARRAY_ELEMENT) ZEND_VM_HANDLER(ZEND_ADD_ARRAY_ELEMENT) { @@ -3003,7 +3011,7 @@ ZEND_VM_HANDLER(ZEND_ADD_ARRAY_ELEMENT) } #endif -#define ZEND_CAST_SPEC() OPDEF(ZEND_CAST, M_CONST_TMP_VAR, M_ANY) +#define ZEND_CAST_SPEC() OPDEF(ZEND_CAST, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_CAST) ZEND_VM_HANDLER(ZEND_CAST) { @@ -3052,7 +3060,7 @@ ZEND_VM_HANDLER(ZEND_CAST) } #endif -#define ZEND_INCLUDE_OR_EVAL_SPEC() OPDEF(ZEND_INCLUDE_OR_EVAL, M_CONST_TMP_VAR, M_ANY) +#define ZEND_INCLUDE_OR_EVAL_SPEC() OPDEF(ZEND_INCLUDE_OR_EVAL, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_INCLUDE_OR_EVAL) ZEND_VM_HANDLER(ZEND_INCLUDE_OR_EVAL) { @@ -3174,7 +3182,7 @@ ZEND_VM_HANDLER(ZEND_INCLUDE_OR_EVAL) } #endif -#define ZEND_UNSET_VAR_SPEC() OPDEF(ZEND_UNSET_VAR, M_CONST_TMP_VAR, M_ANY) +#define ZEND_UNSET_VAR_SPEC() OPDEF(ZEND_UNSET_VAR, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_UNSET_VAR) ZEND_VM_HANDLER(ZEND_UNSET_VAR) { @@ -3195,8 +3203,22 @@ ZEND_VM_HANDLER(ZEND_UNSET_VAR) if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) { zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC); } else { - target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC); - zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1); + target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC); + if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) { + zend_execute_data *ex = EXECUTE_DATA; + do { + int i; + + for (i = 0; i < ex->op_array->last_var; i++) { + if (ex->op_array->vars[i].name_len == varname->value.str.len && + !memcmp(ex->op_array->vars[i].name, varname->value.str.val, varname->value.str.len)) { + ex->CVs[i] = NULL; + break; + } + } + ex = ex->prev_execute_data; + } while (ex && ex->symbol_table == target_symbol_table); + } } if (varname == &tmp) { @@ -3207,7 +3229,7 @@ ZEND_VM_HANDLER(ZEND_UNSET_VAR) } #endif -#define ZEND_UNSET_DIM_OBJ_SPEC() OPDEF(ZEND_UNSET_DIM_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_UNSET_DIM_OBJ_SPEC() OPDEF(ZEND_UNSET_DIM_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_UNSET_DIM_OBJ) ZEND_VM_HANDLER(ZEND_UNSET_DIM_OBJ) { @@ -3260,7 +3282,23 @@ ZEND_VM_HANDLER(ZEND_UNSET_DIM_OBJ) zend_hash_index_del(ht, index); break; case IS_STRING: - zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1); + if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS && + ht == &EG(symbol_table)) { + zend_execute_data *ex; + for (ex = EXECUTE_DATA; ex; ex = ex->prev_execute_data) { + if (ex->symbol_table == ht) { + int i; + + for (i = 0; i < ex->op_array->last_var; i++) { + if (ex->op_array->vars[i].name_len == offset->value.str.len && + !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) { + ex->CVs[i] = NULL; + break; + } + } + } + } + } break; case IS_NULL: zend_hash_del(ht, "", sizeof("")); @@ -3280,7 +3318,7 @@ ZEND_VM_HANDLER(ZEND_UNSET_DIM_OBJ) } #endif -#define ZEND_FE_RESET_SPEC() OPDEF(ZEND_FE_RESET, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FE_RESET_SPEC() OPDEF(ZEND_FE_RESET, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_FE_RESET) ZEND_VM_HANDLER(ZEND_FE_RESET) { @@ -3366,7 +3404,7 @@ ZEND_VM_HANDLER(ZEND_FE_RESET) } #endif -#define ZEND_FE_FETCH_SPEC() OPDEF(ZEND_FE_FETCH, M_CONST_TMP_VAR, M_ANY) +#define ZEND_FE_FETCH_SPEC() OPDEF(ZEND_FE_FETCH, M_VAR, M_ANY) #if HAVE_OP(ZEND_FE_FETCH) ZEND_VM_HANDLER(ZEND_FE_FETCH) { @@ -3504,7 +3542,7 @@ ZEND_VM_HANDLER(ZEND_FE_FETCH) } #endif -#define ZEND_JMP_NO_CTOR_SPEC() OPDEF(ZEND_JMP_NO_CTOR, M_TMP_VAR, M_ANY) +#define ZEND_JMP_NO_CTOR_SPEC() OPDEF(ZEND_JMP_NO_CTOR, M_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_JMP_NO_CTOR) ZEND_VM_HANDLER(ZEND_JMP_NO_CTOR) { @@ -3535,13 +3573,13 @@ ZEND_VM_HANDLER(ZEND_JMP_NO_CTOR) } #endif -#define ZEND_ISSET_ISEMPTY_VAR_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_VAR, M_CONST_TMP_VAR, M_ANY) +#define ZEND_ISSET_ISEMPTY_VAR_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_VAR, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_ISSET_ISEMPTY_VAR) ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_VAR) { zend_op *opline = EX(opline); zend_free_op free_op1; - zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_R); + zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS); zval **value; zend_bool isset = 1; HashTable *target_symbol_table; @@ -3593,12 +3631,12 @@ ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_VAR) } #endif -#if OP1_OP2_MASK(M_VAR_UNUSED, M_CONST_TMP_VAR) +#if OP1_OP2_MASK(M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, int prop_dim) { zend_op *opline = EX(opline); zend_free_op free_op1, free_op2; - zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_R); + zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_IS); zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R); zval **value = NULL; int result = 0; @@ -3697,7 +3735,7 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, int prop_dim) } #endif -#define ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_DIM_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_DIM_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ISSET_ISEMPTY_DIM_OBJ) ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_DIM_OBJ) { @@ -3705,7 +3743,7 @@ ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_DIM_OBJ) } #endif -#define ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_PROP_OBJ, M_VAR_UNUSED, M_CONST_TMP_VAR) +#define ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC() OPDEF(ZEND_ISSET_ISEMPTY_PROP_OBJ, M_VAR_UNUSED_CV, M_CONST_TMP_VAR_CV) #if HAVE_OP(ZEND_ISSET_ISEMPTY_PROP_OBJ) ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_PROP_OBJ) { @@ -3713,7 +3751,7 @@ ZEND_VM_HANDLER(ZEND_ISSET_ISEMPTY_PROP_OBJ) } #endif -#define ZEND_EXIT_SPEC() OPDEF(ZEND_EXIT, M_CONST_TMP_VAR_UNUSED, M_ANY) +#define ZEND_EXIT_SPEC() OPDEF(ZEND_EXIT, M_CONST_TMP_VAR_UNUSED_CV, M_ANY) #if HAVE_OP(ZEND_EXIT) ZEND_VM_HANDLER(ZEND_EXIT) { @@ -3776,7 +3814,7 @@ ZEND_VM_HANDLER(ZEND_END_SILENCE) } #endif -#define ZEND_QM_ASSIGN_SPEC() OPDEF(ZEND_QM_ASSIGN, M_CONST_TMP_VAR, M_ANY) +#define ZEND_QM_ASSIGN_SPEC() OPDEF(ZEND_QM_ASSIGN, M_CONST_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_QM_ASSIGN) ZEND_VM_HANDLER(ZEND_QM_ASSIGN) { @@ -3873,7 +3911,7 @@ ZEND_VM_HANDLER(ZEND_TICKS) } #endif -#define ZEND_INSTANCEOF_SPEC() OPDEF(ZEND_INSTANCEOF, M_TMP_VAR, M_ANY) +#define ZEND_INSTANCEOF_SPEC() OPDEF(ZEND_INSTANCEOF, M_TMP_VAR_CV, M_ANY) #if HAVE_OP(ZEND_INSTANCEOF) ZEND_VM_HANDLER(ZEND_INSTANCEOF) { diff --git a/Zend/zend_vm_spec.h b/Zend/zend_vm_spec.h index 8525da058d..2514870cef 100644 --- a/Zend/zend_vm_spec.h +++ b/Zend/zend_vm_spec.h @@ -83,114 +83,133 @@ #define SPEC__TMP_CODE _TMP_CODE #define SPEC__VAR_CODE _VAR_CODE #define SPEC__UNUSED_CODE _UNUSED_CODE +#define SPEC__CV_CODE _CV_CODE #define SPEC_OP1_TYPE_ANY opline->op1.op_type #define SPEC_OP1_TYPE_CONST IS_CONST #define SPEC_OP1_TYPE_TMP IS_TMP_VAR #define SPEC_OP1_TYPE_VAR IS_VAR #define SPEC_OP1_TYPE_UNUSED IS_UNUSED +#define SPEC_OP1_TYPE_CV IS_CV -#define SPEC_GET_OP1_ZVAL_PTR_ANY(T) _get_zval_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_ZVAL_PTR_ANY(T) get_zval_ptr(&opline->op1, EX(Ts), &free_op1, T) #define SPEC_GET_OP1_ZVAL_PTR_CONST(T) _get_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_TMP(T) _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_VAR(T) _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_UNUSED(T) _get_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_ZVAL_PTR_CV(T) _get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC) -#define SPEC_GET_OP1_ZVAL_PTR_PTR_ANY(T) _get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_ZVAL_PTR_PTR_ANY(T) get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, T) #define SPEC_GET_OP1_ZVAL_PTR_PTR_CONST(T) _get_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_PTR_TMP(T) _get_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_PTR_VAR(T) _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_ZVAL_PTR_PTR_UNUSED(T) _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_ZVAL_PTR_PTR_CV(T) _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC) -#define SPEC_GET_OP1_OBJ_ZVAL_PTR_ANY(T) _get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_OBJ_ZVAL_PTR_ANY(T) get_obj_zval_ptr(&opline->op1, EX(Ts), &free_op1, T) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_CONST(T) _get_obj_zval_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_TMP(T) _get_obj_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_VAR(T) _get_obj_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_UNUSED(T) _get_obj_zval_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_OBJ_ZVAL_PTR_CV(T) _get_obj_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC) -#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_ANY(T) _get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_ANY(T) get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, T) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_CONST(T) _get_obj_zval_ptr_ptr_const(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_TMP(T) _get_obj_zval_ptr_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_VAR(T) _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) #define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_UNUSED(T) _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC) +#define SPEC_GET_OP1_OBJ_ZVAL_PTR_PTR_CV(T) _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, T TSRMLS_CC) #define SPEC_IS_OP1_TMP_FREE_ANY() IS_TMP_FREE(free_op1) #define SPEC_IS_OP1_TMP_FREE_CONST() 0 #define SPEC_IS_OP1_TMP_FREE_TMP() 1 #define SPEC_IS_OP1_TMP_FREE_VAR() 0 #define SPEC_IS_OP1_TMP_FREE_UNUSED() 0 +#define SPEC_IS_OP1_TMP_FREE_CV() 0 #define SPEC_FREE_OP1_ANY() FREE_OP(free_op1); #define SPEC_FREE_OP1_CONST() #define SPEC_FREE_OP1_TMP() zval_dtor(free_op1.var) #define SPEC_FREE_OP1_VAR() FREE_OP_VAR_PTR(free_op1); #define SPEC_FREE_OP1_UNUSED() +#define SPEC_FREE_OP1_CV() #define SPEC_FREE_OP1_IF_VAR_ANY() FREE_OP_IF_VAR(free_op1); #define SPEC_FREE_OP1_IF_VAR_CONST() #define SPEC_FREE_OP1_IF_VAR_TMP() #define SPEC_FREE_OP1_IF_VAR_VAR() FREE_OP_VAR_PTR(free_op1); #define SPEC_FREE_OP1_IF_VAR_UNUSED() +#define SPEC_FREE_OP1_IF_VAR_CV() #define SPEC_FREE_OP1_VAR_PTR_ANY() FREE_OP_VAR_PTR(free_op1); #define SPEC_FREE_OP1_VAR_PTR_CONST() #define SPEC_FREE_OP1_VAR_PTR_TMP() #define SPEC_FREE_OP1_VAR_PTR_VAR() FREE_OP_VAR_PTR(free_op1); #define SPEC_FREE_OP1_VAR_PTR_UNUSED() +#define SPEC_FREE_OP1_VAR_PTR_CV() #define SPEC_OP2_TYPE_ANY opline->op2.op_type #define SPEC_OP2_TYPE_CONST IS_CONST #define SPEC_OP2_TYPE_TMP IS_TMP_VAR #define SPEC_OP2_TYPE_VAR IS_VAR #define SPEC_OP2_TYPE_UNUSED IS_UNUSED +#define SPEC_OP2_TYPE_CV IS_CV -#define SPEC_GET_OP2_ZVAL_PTR_ANY(T) _get_zval_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_ZVAL_PTR_ANY(T) get_zval_ptr(&opline->op2, EX(Ts), &free_op2, T) #define SPEC_GET_OP2_ZVAL_PTR_CONST(T) _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_TMP(T) _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_VAR(T) _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_UNUSED(T) _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_ZVAL_PTR_CV(T) _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC) -#define SPEC_GET_OP2_ZVAL_PTR_PTR_ANY(T) _get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_ZVAL_PTR_PTR_ANY(T) get_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, T) #define SPEC_GET_OP2_ZVAL_PTR_PTR_CONST(T) _get_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_PTR_TMP(T) _get_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_PTR_VAR(T) _get_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_ZVAL_PTR_PTR_UNUSED(T) _get_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_ZVAL_PTR_PTR_CV(T) _get_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC) -#define SPEC_GET_OP2_OBJ_ZVAL_PTR_ANY(T) _get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_OBJ_ZVAL_PTR_ANY(T) get_obj_zval_ptr(&opline->op2, EX(Ts), &free_op2, T) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_CONST(T) _get_obj_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_TMP(T) _get_obj_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_VAR(T) _get_obj_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_UNUSED(T) _get_obj_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_OBJ_ZVAL_PTR_CV(T) _get_obj_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC) -#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_ANY(T) _get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_ANY(T) get_obj_zval_ptr_ptr(&opline->op2, EX(Ts), &free_op2, T) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_CONST(T) _get_obj_zval_ptr_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_TMP(T) _get_obj_zval_ptr_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_VAR(T) _get_obj_zval_ptr_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) #define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_UNUSED(T) _get_obj_zval_ptr_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC) +#define SPEC_GET_OP2_OBJ_ZVAL_PTR_PTR_CV(T) _get_obj_zval_ptr_ptr_cv(&opline->op2, EX(Ts), &free_op2, T TSRMLS_CC) #define SPEC_IS_OP2_TMP_FREE_ANY() IS_TMP_FREE(free_op2) #define SPEC_IS_OP2_TMP_FREE_CONST() 0 #define SPEC_IS_OP2_TMP_FREE_TMP() 1 #define SPEC_IS_OP2_TMP_FREE_VAR() 0 #define SPEC_IS_OP2_TMP_FREE_UNUSED() 0 +#define SPEC_IS_OP2_TMP_FREE_CV() 0 #define SPEC_FREE_OP2_ANY() FREE_OP(free_op2); #define SPEC_FREE_OP2_CONST() #define SPEC_FREE_OP2_TMP() zval_dtor(free_op2.var) #define SPEC_FREE_OP2_VAR() FREE_OP_VAR_PTR(free_op2); #define SPEC_FREE_OP2_UNUSED() +#define SPEC_FREE_OP2_CV() #define SPEC_FREE_OP2_IF_VAR_ANY() FREE_OP_IF_VAR(free_op2); #define SPEC_FREE_OP2_IF_VAR_CONST() #define SPEC_FREE_OP2_IF_VAR_TMP() #define SPEC_FREE_OP2_IF_VAR_VAR() FREE_OP_VAR_PTR(free_op2); #define SPEC_FREE_OP2_IF_VAR_UNUSED() +#define SPEC_FREE_OP2_IF_VAR_CV() #define SPEC_FREE_OP2_VAR_PTR_ANY() FREE_OP_VAR_PTR(free_op2); #define SPEC_FREE_OP2_VAR_PTR_CONST() #define SPEC_FREE_OP2_VAR_PTR_TMP() #define SPEC_FREE_OP2_VAR_PTR_VAR() FREE_OP_VAR_PTR(free_op2); #define SPEC_FREE_OP2_VAR_PTR_UNUSED() +#define SPEC_FREE_OP2_VAR_PTR_CV() #ifndef ZEND_VM_SPEC @@ -208,22 +227,38 @@ #else -# define M_ANY (IS_ANY) -# define M_CONST (IS_CONST) -# define M_TMP (IS_TMP_VAR) -# define M_VAR (IS_VAR) -# define M_UNUSED (IS_UNUSED) -# define M_CONST_TMP (IS_CONST|IS_TMP_VAR) -# define M_CONST_VAR (IS_CONST|IS_VAR) -# define M_CONST_UNUSED (IS_CONST|IS_UNUSED) -# define M_CONST_TMP_VAR (IS_CONST|IS_TMP_VAR|IS_VAR) -# define M_CONST_TMP_UNUSED (IS_CONST|IS_TMP_VAR|IS_UNUSED) -# define M_CONST_VAR_UNUSED (IS_CONST|IS_VAR|IS_UNUSED) -# define M_CONST_TMP_VAR_UNUSED (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED) -# define M_TMP_VAR (IS_TMP_VAR|IS_VAR) -# define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED) -# define M_TMP_VAR_UNUSED (IS_TMP_VAR|IS_VAR|IS_UNUSED) -# define M_VAR_UNUSED (IS_VAR|IS_UNUSED) +# define M_ANY (IS_ANY) +# define M_CONST (IS_CONST) +# define M_TMP (IS_TMP_VAR) +# define M_VAR (IS_VAR) +# define M_UNUSED (IS_UNUSED) +# define M_CONST_TMP (IS_CONST|IS_TMP_VAR) +# define M_CONST_VAR (IS_CONST|IS_VAR) +# define M_CONST_UNUSED (IS_CONST|IS_UNUSED) +# define M_CONST_TMP_VAR (IS_CONST|IS_TMP_VAR|IS_VAR) +# define M_CONST_TMP_UNUSED (IS_CONST|IS_TMP_VAR|IS_UNUSED) +# define M_CONST_VAR_UNUSED (IS_CONST|IS_VAR|IS_UNUSED) +# define M_CONST_TMP_VAR_UNUSED (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED) +# define M_TMP_VAR (IS_TMP_VAR|IS_VAR) +# define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED) +# define M_TMP_VAR_UNUSED (IS_TMP_VAR|IS_VAR|IS_UNUSED) +# define M_VAR_UNUSED (IS_VAR|IS_UNUSED) +# define M_CV (IS_CV) +# define M_CONST_CV (IS_CONST|IS_CV) +# define M_TMP_CV (IS_TMP_VAR|IS_CV) +# define M_VAR_CV (IS_VAR|IS_CV) +# define M_UNUSED_CV (IS_UNUSED|IS_CV) +# define M_CONST_TMP_CV (IS_CONST|IS_TMP_VAR|IS_CV) +# define M_CONST_VAR_CV (IS_CONST|IS_VAR|IS_CV) +# define M_CONST_UNUSED_CV (IS_CONST|IS_UNUSED|IS_CV) +# define M_CONST_TMP_VAR_CV (IS_CONST|IS_TMP_VAR|IS_VAR|IS_CV) +# define M_CONST_TMP_UNUSED_CV (IS_CONST|IS_TMP_VAR|IS_UNUSED|IS_CV) +# define M_CONST_VAR_UNUSED_CV (IS_CONST|IS_VAR|IS_UNUSED|IS_CV) +# define M_CONST_TMP_VAR_UNUSED_CV (IS_CONST|IS_TMP_VAR|IS_VAR|IS_UNUSED|IS_CV) +# define M_TMP_VAR_CV (IS_TMP_VAR|IS_VAR|IS_CV) +# define M_TMP_UNUSED_CV (IS_TMP_VAR|IS_UNUSED|IS_CV) +# define M_TMP_VAR_UNUSED_CV (IS_TMP_VAR|IS_VAR|IS_UNUSED|IS_CV) +# define M_VAR_UNUSED_CV (IS_VAR|IS_UNUSED|IS_CV) # define OP1_OP2_MASK(OP1T, OP2T) \ ((OP1 & (OP1T)) && (OP2 & (OP2T))) @@ -334,6 +369,12 @@ # define OP2 IS_ANY # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_ANY +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_ANY @@ -358,6 +399,12 @@ # define OP2 IS_UNUSED # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_ANY +# define OP2 IS_CV +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_UNUSED @@ -382,6 +429,12 @@ # define OP2 IS_VAR # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_UNUSED +# define OP2 IS_CV +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_CONST @@ -400,6 +453,12 @@ # define OP2 IS_UNUSED # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_UNUSED +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_CONST @@ -418,6 +477,12 @@ # define OP2 IS_VAR # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_CONST +# define OP2 IS_CV +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_TMP_VAR @@ -436,6 +501,12 @@ # define OP2 IS_VAR # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_TMP_VAR +# define OP2 IS_CV +# include "zend_vm_handlers.h" + # undef OP1 # undef OP2 # define OP1 IS_VAR @@ -454,6 +525,36 @@ # define OP2 IS_VAR # include "zend_vm_handlers.h" +# undef OP1 +# undef OP2 +# define OP1 IS_VAR +# define OP2 IS_CV +# include "zend_vm_handlers.h" + +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_CONST +# include "zend_vm_handlers.h" + +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_TMP_VAR +# include "zend_vm_handlers.h" + +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_VAR +# include "zend_vm_handlers.h" + +# undef OP1 +# undef OP2 +# define OP1 IS_CV +# define OP2 IS_CV +# include "zend_vm_handlers.h" + /* LABELS */ # undef M_ANY @@ -472,6 +573,22 @@ # undef M_TMP_UNUSED # undef M_TMP_VAR_UNUSED # undef M_VAR_UNUSED +# undef M_CV +# undef M_CONST_CV +# undef M_TMP_CV +# undef M_VAR_CV +# undef M_UNUSED_CV +# undef M_CONST_TMP_CV +# undef M_CONST_VAR_CV +# undef M_CONST_UNUSED_CV +# undef M_CONST_TMP_VAR_CV +# undef M_CONST_TMP_UNUSED_CV +# undef M_CONST_VAR_UNUSED_CV +# undef M_CONST_TMP_VAR_UNUSED_CV +# undef M_TMP_VAR_CV +# undef M_TMP_UNUSED_CV +# undef M_TMP_VAR_UNUSED_CV +# undef M_VAR_UNUSED_CV # undef OPDEF @@ -479,92 +596,160 @@ SPEC_LABELS1_##OP1M(OP##_SPEC, OP, OP2M) # define SPEC_LABELS1_M_ANY(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _ANY, _ANY, _ANY, _ANY) + SPEC_LABELS2_##OP2M(OP, CODE, _ANY, _ANY, _ANY, _ANY, _ANY) # define SPEC_LABELS1_M_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED, _NULL) # define SPEC_LABELS1_M_VAR(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL, _NULL) # define SPEC_LABELS1_M_VAR_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED, _NULL) # define SPEC_LABELS1_M_TMP(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL, _NULL) # define SPEC_LABELS1_M_TMP_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED, _NULL) # define SPEC_LABELS1_M_TMP_VAR(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL, _NULL) # define SPEC_LABELS1_M_TMP_VAR_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED, _NULL) # define SPEC_LABELS1_M_CONST(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL, _NULL) # define SPEC_LABELS1_M_CONST_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED, _NULL) # define SPEC_LABELS1_M_CONST_VAR(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL, _NULL) # define SPEC_LABELS1_M_CONST_VAR_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED, _NULL) # define SPEC_LABELS1_M_CONST_TMP(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL, _NULL) # define SPEC_LABELS1_M_CONST_TMP_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED, _NULL) # define SPEC_LABELS1_M_CONST_TMP_VAR(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL) + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL, _NULL) # define SPEC_LABELS1_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP2M) \ - SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED) - -# define SPEC_LABELS2_M_ANY(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _ANY, _ANY, _ANY, _ANY) -# define SPEC_LABELS2_M_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _NULL, _UNUSED) -# define SPEC_LABELS2_M_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _NULL) -# define SPEC_LABELS2_M_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _UNUSED) -# define SPEC_LABELS2_M_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _NULL) -# define SPEC_LABELS2_M_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _UNUSED) -# define SPEC_LABELS2_M_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _NULL) -# define SPEC_LABELS2_M_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _UNUSED) -# define SPEC_LABELS2_M_CONST(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _NULL) -# define SPEC_LABELS2_M_CONST_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _UNUSED) -# define SPEC_LABELS2_M_CONST_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _NULL) -# define SPEC_LABELS2_M_CONST_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _UNUSED) -# define SPEC_LABELS2_M_CONST_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _NULL) -# define SPEC_LABELS2_M_CONST_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _UNUSED) -# define SPEC_LABELS2_M_CONST_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _NULL) -# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U) \ - SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _UNUSED) - -# define LABELS_1(OP,CODE,OP1,OP2C,OP2T,OP2V,OP2U) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED, _NULL) +# define SPEC_LABELS1_M_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _NULL, _CV) +# define SPEC_LABELS1_M_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _NULL, _UNUSED, _CV) +# define SPEC_LABELS1_M_VAR_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _NULL, _CV) +# define SPEC_LABELS1_M_VAR_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _NULL, _VAR, _UNUSED, _CV) +# define SPEC_LABELS1_M_TMP_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _NULL, _CV) +# define SPEC_LABELS1_M_TMP_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _NULL, _UNUSED, _CV) +# define SPEC_LABELS1_M_TMP_VAR_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _NULL, _CV) +# define SPEC_LABELS1_M_TMP_VAR_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _NULL, _TMP, _VAR, _UNUSED, _CV) +# define SPEC_LABELS1_M_CONST_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _NULL, _CV) +# define SPEC_LABELS1_M_CONST_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _NULL, _UNUSED, _CV) +# define SPEC_LABELS1_M_CONST_VAR_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _NULL, _CV) +# define SPEC_LABELS1_M_CONST_VAR_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _NULL, _VAR, _UNUSED, _CV) +# define SPEC_LABELS1_M_CONST_TMP_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _NULL, _CV) +# define SPEC_LABELS1_M_CONST_TMP_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _NULL, _UNUSED, _CV) +# define SPEC_LABELS1_M_CONST_TMP_VAR_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _NULL, _CV) +# define SPEC_LABELS1_M_CONST_TMP_VAR_UNUSED_CV(OP, CODE, OP2M) \ + SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED, _CV) + +# define SPEC_LABELS2_M_ANY(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _ANY, _ANY, _ANY, _ANY, _NULL) +# define SPEC_LABELS2_M_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _UNUSED, _NULL) +# define SPEC_LABELS2_M_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _NULL, _NULL) +# define SPEC_LABELS2_M_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _UNUSED, _NULL) +# define SPEC_LABELS2_M_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _NULL, _NULL) +# define SPEC_LABELS2_M_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _UNUSED, _NULL) +# define SPEC_LABELS2_M_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _NULL, _NULL) +# define SPEC_LABELS2_M_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _UNUSED, _NULL) +# define SPEC_LABELS2_M_CONST(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _NULL, _NULL) +# define SPEC_LABELS2_M_CONST_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _UNUSED, _NULL) +# define SPEC_LABELS2_M_CONST_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _NULL, _NULL) +# define SPEC_LABELS2_M_CONST_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _UNUSED, _NULL) +# define SPEC_LABELS2_M_CONST_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _NULL, _NULL) +# define SPEC_LABELS2_M_CONST_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _UNUSED, _NULL) +# define SPEC_LABELS2_M_CONST_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _NULL, _NULL) +# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _UNUSED, _NULL) +# define SPEC_LABELS2_M_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _NULL, _CV) +# define SPEC_LABELS2_M_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _NULL, _UNUSED, _CV) +# define SPEC_LABELS2_M_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _NULL, _CV) +# define SPEC_LABELS2_M_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _NULL, _VAR, _UNUSED, _CV) +# define SPEC_LABELS2_M_TMP_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _NULL, _CV) +# define SPEC_LABELS2_M_TMP_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _NULL, _UNUSED, _CV) +# define SPEC_LABELS2_M_TMP_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _NULL, _CV) +# define SPEC_LABELS2_M_TMP_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _NULL, _TMP, _VAR, _UNUSED, _CV) +# define SPEC_LABELS2_M_CONST_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _NULL, _CV) +# define SPEC_LABELS2_M_CONST_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _NULL, _UNUSED, _CV) +# define SPEC_LABELS2_M_CONST_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _NULL, _CV) +# define SPEC_LABELS2_M_CONST_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _NULL, _VAR, _UNUSED, _CV) +# define SPEC_LABELS2_M_CONST_TMP_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _NULL, _CV) +# define SPEC_LABELS2_M_CONST_TMP_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _NULL, _UNUSED, _CV) +# define SPEC_LABELS2_M_CONST_TMP_VAR_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _NULL, _CV) +# define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED_CV(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \ + SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X, _CONST, _TMP, _VAR, _UNUSED, _CV) + +# define LABELS_1(OP,CODE,OP1,OP2C,OP2T,OP2V,OP2U,OP2X) \ OP1##OP2C(OP,CODE), \ OP1##OP2T(OP,CODE), \ OP1##OP2V(OP,CODE), \ - OP1##OP2U(OP,CODE) + OP1##OP2U(OP,CODE), \ + OP1##OP2X(OP,CODE) -# define SPEC_LABELS(OP,CODE,OP1C,OP1T,OP1V,OP1U,OP2C,OP2T,OP2V,OP2U) \ - LABELS_1(OP,CODE,SPEC_LABEL##OP1C,OP2C,OP2T,OP2V,OP2U), \ - LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U), \ - LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U), \ - LABELS_1(OP,CODE,SPEC_LABEL##OP1U,OP2C,OP2T,OP2V,OP2U) +# define SPEC_LABELS(OP,CODE,OP1C,OP1T,OP1V,OP1U,OP1X,OP2C,OP2T,OP2V,OP2U,OP2X) \ + LABELS_1(OP,CODE,SPEC_LABEL##OP1C,OP2C,OP2T,OP2V,OP2U,OP2X), \ + LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U,OP2X), \ + LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U,OP2X), \ + LABELS_1(OP,CODE,SPEC_LABEL##OP1U,OP2C,OP2T,OP2V,OP2U,OP2X), \ + LABELS_1(OP,CODE,SPEC_LABEL##OP1X,OP2C,OP2T,OP2V,OP2U,OP2X) # define SPEC_LABEL_CONST_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_TMP_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_VAR_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_UNUSED_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL +# define SPEC_LABEL_CV_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_ANY_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_CONST(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_TMP(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_VAR(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_UNUSED(OP,CODE) ZEND_VM_SPEC_NULL_LABEL +# define SPEC_LABEL_NULL_CV(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_ANY(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_NULL_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL # define SPEC_LABEL_ANY_ANY(OP,CODE) \ @@ -577,6 +762,8 @@ ZEND_VM_SPEC_LABEL(OP##_ANY_VAR, ZEND_VM_CODE(CODE, _ANY_CODE, _VAR_CODE)) # define SPEC_LABEL_ANY_UNUSED(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_ANY_UNUSED, ZEND_VM_CODE(CODE, _ANY_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_ANY_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_ANY_CV, ZEND_VM_CODE(CODE, _ANY_CODE, _CV_CODE)) # define SPEC_LABEL_CONST_ANY(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_CONST_ANY, ZEND_VM_CODE(CODE, _CONST_CODE, _ANY_CODE)) # define SPEC_LABEL_CONST_CONST(OP,CODE) \ @@ -587,6 +774,8 @@ ZEND_VM_SPEC_LABEL(OP##_CONST_VAR, ZEND_VM_CODE(CODE, _CONST_CODE, _VAR_CODE)) # define SPEC_LABEL_CONST_UNUSED(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_CONST_UNUSED, ZEND_VM_CODE(CODE, _CONST_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_CONST_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CONST_CV, ZEND_VM_CODE(CODE, _CONST_CODE, _CV_CODE)) # define SPEC_LABEL_TMP_ANY(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_TMP_ANY, ZEND_VM_CODE(CODE, _TMP_CODE, _ANY_CODE)) # define SPEC_LABEL_TMP_CONST(OP,CODE) \ @@ -597,6 +786,8 @@ ZEND_VM_SPEC_LABEL(OP##_TMP_VAR, ZEND_VM_CODE(CODE, _TMP_CODE, _VAR_CODE)) # define SPEC_LABEL_TMP_UNUSED(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_TMP_UNUSED, ZEND_VM_CODE(CODE, _TMP_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_TMP_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_TMP_CV, ZEND_VM_CODE(CODE, _TMP_CODE, _CV_CODE)) # define SPEC_LABEL_VAR_ANY(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_VAR_ANY, ZEND_VM_CODE(CODE, _VAR_CODE, _ANY_CODE)) # define SPEC_LABEL_VAR_CONST(OP,CODE) \ @@ -607,6 +798,8 @@ ZEND_VM_SPEC_LABEL(OP##_VAR_VAR, ZEND_VM_CODE(CODE, _VAR_CODE, _VAR_CODE)) # define SPEC_LABEL_VAR_UNUSED(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_VAR_UNUSED, ZEND_VM_CODE(CODE, _VAR_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_VAR_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_VAR_CV, ZEND_VM_CODE(CODE, _VAR_CODE, _CV_CODE)) # define SPEC_LABEL_UNUSED_ANY(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_UNUSED_ANY, ZEND_VM_CODE(CODE, _UNUSED_CODE, _ANY_CODE)) # define SPEC_LABEL_UNUSED_CONST(OP,CODE) \ @@ -617,6 +810,20 @@ ZEND_VM_SPEC_LABEL(OP##_UNUSED_VAR, ZEND_VM_CODE(CODE, _UNUSED_CODE, _VAR_CODE)) # define SPEC_LABEL_UNUSED_UNUSED(OP,CODE) \ ZEND_VM_SPEC_LABEL(OP##_UNUSED_UNUSED, ZEND_VM_CODE(CODE, _UNUSED_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_UNUSED_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_UNUSED_CV, ZEND_VM_CODE(CODE, _UNUSED_CODE, _CV_CODE)) +# define SPEC_LABEL_CV_ANY(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_ANY, ZEND_VM_CODE(CODE, _CV_CODE, _ANY_CODE)) +# define SPEC_LABEL_CV_CONST(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_CONST, ZEND_VM_CODE(CODE, _CV_CODE, _CONST_CODE)) +# define SPEC_LABEL_CV_TMP(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_TMP, ZEND_VM_CODE(CODE, _CV_CODE, _TMP_CODE)) +# define SPEC_LABEL_CV_VAR(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_VAR, ZEND_VM_CODE(CODE, _CV_CODE, _VAR_CODE)) +# define SPEC_LABEL_CV_UNUSED(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_UNUSED, ZEND_VM_CODE(CODE, _CV_CODE, _UNUSED_CODE)) +# define SPEC_LABEL_CV_CV(OP,CODE) \ + ZEND_VM_SPEC_LABEL(OP##_CV_CV, ZEND_VM_CODE(CODE, _CV_CODE, _CV_CODE)) # undef ZEND_VM_NULL_LABEL # define ZEND_VM_NULL_LABEL \ @@ -635,6 +842,15 @@ ZEND_VM_SPEC_NULL_LABEL, \ ZEND_VM_SPEC_NULL_LABEL, \ ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ + ZEND_VM_SPEC_NULL_LABEL, \ ZEND_VM_SPEC_NULL_LABEL # undef ZEND_VM_LABEL @@ -643,7 +859,7 @@ #endif -#if defined(ZEND_VM_SPEC) && (ZEND_VM_KIND == ZEND_VM_KIND_CALL) +#if defined(ZEND_VM_HAVE_OLD_EXECUTOR) && defined(ZEND_VM_SPEC) && (ZEND_VM_KIND == ZEND_VM_KIND_CALL) ZEND_VM_NULL_HANDLER(); #else ZEND_VM_NULL_HANDLER() diff --git a/ext/session/session.c b/ext/session/session.c index a6cf1356d2..3df802c2b9 100644 --- a/ext/session/session.c +++ b/ext/session/session.c @@ -526,9 +526,8 @@ static void php_session_track_init(TSRMLS_D) zval *session_vars = NULL; /* Unconditionally destroy existing arrays -- possible dirty data */ - zend_hash_del(&EG(symbol_table), "HTTP_SESSION_VARS", - sizeof("HTTP_SESSION_VARS")); - zend_hash_del(&EG(symbol_table), "_SESSION", sizeof("_SESSION")); + delete_global_variable("HTTP_SESSION_VARS", sizeof("HTTP_SESSION_VARS")-1 TSRMLS_CC); + delete_global_variable("_SESSION", sizeof("_SESSION")-1 TSRMLS_CC); MAKE_STD_ZVAL(session_vars); array_init(session_vars); @@ -1680,7 +1679,7 @@ PHP_FUNCTION(session_unset) while (zend_hash_get_current_key_ex(ht, &str, &str_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING) { - zend_hash_del(&EG(symbol_table), str, str_len); + delete_global_variable(str, str_len-1 TSRMLS_CC); zend_hash_move_forward_ex(ht, &pos); } } diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 34645a18ef..ecc1bc0a21 100755 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -278,8 +278,14 @@ static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC) switch(Z_TYPE_P(offset)) { case IS_STRING: - if (zend_symtable_del(HASH_OF(intern->array), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) { - zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset)); + if (HASH_OF(intern->array) == &EG(symbol_table)) { + if (delete_global_variable(Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC)) { + zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset)); + } + } else { + if (zend_symtable_del(HASH_OF(intern->array), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) { + zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset)); + } } return; case IS_DOUBLE: diff --git a/ext/standard/array.c b/ext/standard/array.c index b491ca4276..4ae9205df3 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -1914,7 +1914,11 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end) /* Delete the first or last value */ zend_hash_get_current_key_ex(Z_ARRVAL_PP(stack), &key, &key_len, &index, 0, NULL); - zend_hash_del_key_or_index(Z_ARRVAL_PP(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX); + if (key && Z_ARRVAL_PP(stack) == &EG(symbol_table)) { + delete_global_variable(key, key_len-1 TSRMLS_CC); + } else { + zend_hash_del_key_or_index(Z_ARRVAL_PP(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX); + } /* If we did a shift... re-index like it did before */ if (!off_the_end) { @@ -2761,7 +2765,11 @@ PHP_FUNCTION(array_unique) p = cmpdata->b; } if (p->nKeyLength) { - zend_hash_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength); + if (Z_ARRVAL_P(return_value) == &EG(symbol_table)) { + delete_global_variable(p->arKey, p->nKeyLength-1 TSRMLS_CC); + } else { + zend_hash_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength); + } } else { zend_hash_index_del(Z_ARRVAL_P(return_value), p->h); } diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index ad5104ff5c..331706ad06 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -3210,7 +3210,7 @@ static int copy_request_variable(void *pDest, int num_args, va_list args, zend_h memcpy(new_key, prefix, prefix_len); memcpy(new_key+prefix_len, hash_key->arKey, hash_key->nKeyLength); - zend_hash_del(&EG(symbol_table), new_key, new_key_len); + delete_global_variable(new_key, new_key_len-1 TSRMLS_CC); ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), new_key, new_key_len, *var, (*var)->refcount+1, 0); efree(new_key);