Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

- 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.
PHP-5.1
Andi Gutmans 21 years ago
parent
bb77132391
commit
db507dd153
15 changed files with 846 additions and 268 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      Zend/Zend.m4
  2. 2
      Zend/zend_API.h
  3. 169
      Zend/zend_compile.c
  4. 14
      Zend/zend_compile.h
  5. 174
      Zend/zend_execute.c
  6. 21
      Zend/zend_execute_API.c
  7. 2
      Zend/zend_language_parser.y
  8. 13
      Zend/zend_opcode.c
  9. 16
      Zend/zend_vm.h
  10. 276
      Zend/zend_vm_handlers.h
  11. 380
      Zend/zend_vm_spec.h
  12. 7
      ext/session/session.c
  13. 10
      ext/spl/spl_array.c
  14. 12
      ext/standard/array.c
  15. 2
      ext/standard/basic_functions.c

16
Zend/Zend.m4
View File

@ -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

2
Zend/zend_API.h
View File

@ -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);

169
Zend/zend_compile.c
View File

@ -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;

14
Zend/zend_compile.h
View File

@ -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 *);

174
Zend/zend_execute.c
View File

@ -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]];
}
}

21
Zend/zend_execute_API.c
View File

@ -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:

2
Zend/zend_language_parser.y
View File

@ -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); }
;

13
Zend/zend_opcode.c
View File

@ -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 (opline<end) {
if (opline->op1.op_type==IS_CONST) {
#if DEBUG_ZEND>2

16
Zend/zend_vm.h
View File

@ -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 { \

276
Zend/zend_vm_handlers.h
File diff suppressed because it is too large
View File

380
Zend/zend_vm_spec.h
View File

@ -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,9 +810,32 @@
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 \
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, \
@ -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()

7
ext/session/session.c
View File

@ -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);
}
}

10
ext/spl/spl_array.c
View File

@ -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:

12
ext/standard/array.c
View File

@ -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);
}

2
ext/standard/basic_functions.c
View File

@ -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);

Write Preview
Loading…
Cancel
Save