archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 05:58:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

- Commit the variable fetch optimization.

Browse source 
- 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.
This commit is contained in:
Andi Gutmans 2004-10-04 19:54:35 +00:00
parent bb77132391
commit db507dd153
15 changed files with 844 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

16
Zend/Zend.m4
View file

@ -108,6 +108,22 @@ AC_ARG_ENABLE(debug,
AC_DEFUN(LIBZEND_OTHER_CHECKS,[ 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, AC_ARG_ENABLE(maintainer-zts,
[ --enable-maintainer-zts Enable thread safety - for code maintainers only],[ [ --enable-maintainer-zts Enable thread safety - for code maintainers only],[
ZEND_MAINTAINER_ZTS=$enableval 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_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
zend_bool is_ref, int num_symbol_tables, ...); 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)) #define add_method(arg, key, method) add_assoc_function((arg), (key), (method))
ZEND_API ZEND_FUNCTION(display_disabled_function); ZEND_API ZEND_FUNCTION(display_disabled_function);

111
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); 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) 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) void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC)
{ {
zend_op opline; zend_op opline;
zend_op *opline_ptr; zend_op *opline_ptr;
zend_llist *fetch_list_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) { if (bp) {
opline_ptr = &opline; opline_ptr = &opline;
init_op(opline_ptr TSRMLS_CC); 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); 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 *fetch_list_ptr;
zend_llist_element *le; zend_llist_element *le;
zend_op *opline_ptr; zend_op *opline_ptr;
zend_op opline;
zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr); zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
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; le = fetch_list_ptr->head;
opline_ptr = (zend_op *)le->data; 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 = *class_znode;
opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER; opline_ptr->op2.u.EA.type = ZEND_FETCH_STATIC_MEMBER;
}
}
} }
void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) 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; *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) void zend_do_free(znode *op1 TSRMLS_DC)
{ {
if (op1->op_type==IS_TMP_VAR) { 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)) { if (op == ZEND_SEND_VAR && zend_is_function_or_method_call(param)) {
/* Method call */ /* Method call */
op = ZEND_SEND_VAR_NO_REF; 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; 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 */ /* change to passing by reference */
switch (param->op_type) { switch (param->op_type) {
case IS_VAR: case IS_VAR:
case IS_CV:
op = ZEND_SEND_REF; op = ZEND_SEND_REF;
break; break;
default: default:
@ -2993,6 +3060,7 @@ void zend_do_list_end(znode *result, znode *expr TSRMLS_DC)
last_container = *expr; last_container = *expr;
switch (expr->op_type) { switch (expr->op_type) {
case IS_VAR: case IS_VAR:
case IS_CV:
opline->opcode = ZEND_FETCH_DIM_R; opline->opcode = ZEND_FETCH_DIM_R;
break; break;
case IS_TMP_VAR: case IS_TMP_VAR:
@ -3166,6 +3234,17 @@ void zend_do_unset(znode *variable TSRMLS_DC)
zend_check_writable_variable(variable); zend_check_writable_variable(variable);
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]; last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
switch (last_op->opcode) { switch (last_op->opcode) {
@ -3182,6 +3261,7 @@ void zend_do_unset(znode *variable TSRMLS_DC)
break; break;
} }
}
} }
@ -3193,6 +3273,16 @@ void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC
zend_check_writable_variable(variable); zend_check_writable_variable(variable);
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]; last_op = &CG(active_op_array)->opcodes[get_next_op_number(CG(active_op_array))-1];
switch (last_op->opcode) { switch (last_op->opcode) {
@ -3206,6 +3296,7 @@ void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC
last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; last_op->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
break; break;
} }
}
last_op->result.op_type = IS_TMP_VAR; last_op->result.op_type = IS_TMP_VAR;
last_op->extended_value = type; 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; int required_num_args;
} zend_arg_info; } zend_arg_info;
typedef struct _zend_compiled_variable {
char *name;
int name_len;
ulong hash_value;
} zend_compiled_variable;
struct _zend_op_array { struct _zend_op_array {
/* Common elements */ /* Common elements */
zend_uchar type; zend_uchar type;
@ -171,6 +177,9 @@ struct _zend_op_array {
zend_op *opcodes; zend_op *opcodes;
zend_uint last, size; zend_uint last, size;
zend_compiled_variable *vars;
int last_var, size_var;
zend_uint T; zend_uint T;
zend_brk_cont_element *brk_cont_array; zend_brk_cont_element *brk_cont_array;
@ -273,8 +282,10 @@ struct _zend_execute_data {
zend_op_array *op_array; zend_op_array *op_array;
zval *object; zval *object;
union _temp_variable *Ts; union _temp_variable *Ts;
zval ***CVs;
zend_bool original_in_execution; zend_bool original_in_execution;
zend_class_entry *calling_scope; zend_class_entry *calling_scope;
HashTable *symbol_table;
struct _zend_execute_data *prev_execute_data; struct _zend_execute_data *prev_execute_data;
}; };
@ -285,6 +296,7 @@ struct _zend_execute_data {
#define IS_TMP_VAR (1<<1) #define IS_TMP_VAR (1<<1)
#define IS_VAR (1<<2) #define IS_VAR (1<<2)
#define IS_UNUSED (1<<3) /* Unused variable */ #define IS_UNUSED (1<<3) /* Unused variable */
#define IS_CV (1<<4) /* Compiled variable */
#define EXT_TYPE_UNUSED (1<<0) #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_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
void fetch_array_dim(znode *result, znode *parent, znode *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 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_print(znode *result, znode *arg TSRMLS_DC);
void zend_do_echo(znode *arg TSRMLS_DC); void zend_do_echo(znode *arg TSRMLS_DC);
typedef int (*unary_op_type)(zval *, zval *); typedef int (*unary_op_type)(zval *, zval *);

172
Zend/zend_execute.c
View file

@ -38,10 +38,10 @@
typedef int (*incdec_t)(zval *); 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(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 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 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 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 */ /* Prototypes */
static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC); 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 */ /* 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; */ /* should_free->is_var = 0; */
switch (node->op_type) { 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; should_free->var = 0;
return NULL; return NULL;
break; 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() EMPTY_SWITCH_DEFAULT_CASE()
} }
return NULL; 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) { if (T(node->u.var).var.ptr_ptr) {
PZVAL_UNLOCK(*T(node->u.var).var.ptr_ptr, should_free); PZVAL_UNLOCK(*T(node->u.var).var.ptr_ptr, should_free);
return T(node->u.var).var.ptr_ptr; 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) static inline zval *_get_zval_ptr_unused(znode *node, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{ {
return NULL; return NULL;
@ -275,6 +363,33 @@ static inline zval **_get_zval_ptr_ptr_unused(znode *node, temp_variable *Ts, ze
return NULL; 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) 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); 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); 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) static inline zval *_get_obj_zval_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{ {
if (EG(This)) { 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); 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) static inline zval **_get_obj_zval_ptr_ptr_unused(znode *op, temp_variable *Ts, zend_free_op *should_free TSRMLS_DC)
{ {
if (EG(This)) { 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 (op->op_type == IS_UNUSED) {
if (EG(This)) { 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"); 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 (op->op_type == IS_UNUSED) {
if (EG(This)) { 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"); 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: case IS_CONST:
/* already a constant string */ /* already a constant string */
break; break;
case IS_CV:
case IS_VAR: case IS_VAR:
tmp = *property_name; tmp = *property_name;
zval_copy_ctor(&tmp); 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) { if (value->type!=IS_STRING) {
tmp = *value; tmp = *value;
if (op2->op_type == IS_VAR) { if (op2->op_type & (IS_VAR|IS_CV)) {
zval_copy_ctor(&tmp); zval_copy_ctor(&tmp);
} }
convert_to_string(&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--; variable_ptr->refcount--;
if (variable_ptr->refcount==0) { if (variable_ptr->refcount==0) {
switch (type) { switch (type) {
case IS_CV:
case IS_VAR: case IS_VAR:
/* break missing intentionally */ /* break missing intentionally */
case IS_CONST: 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 */ } else { /* we need to split */
switch (type) { switch (type) {
case IS_CV:
case IS_VAR: case IS_VAR:
/* break missing intentionally */ /* break missing intentionally */
case IS_CONST: case IS_CONST:
@ -1182,6 +1310,7 @@ static void zend_fetch_property_address(temp_variable *result, zval **container_
case IS_CONST: case IS_CONST:
/* already a constant string */ /* already a constant string */
break; break;
case IS_CV:
case IS_VAR: case IS_VAR:
tmp = *prop_ptr; tmp = *prop_ptr;
zval_copy_ctor(&tmp); zval_copy_ctor(&tmp);
@ -1316,8 +1445,11 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
} else { } else {
EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0); 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(op_array) = op_array;
EX(original_in_execution) = EG(in_execution); EX(original_in_execution) = EG(in_execution);
EX(symbol_table) = EG(active_symbol_table);
EX(prev_execute_data) = EG(current_execute_data); EX(prev_execute_data) = EG(current_execute_data);
EG(current_execute_data) = &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_NULL_LABEL
# undef ZEND_VM_SPEC_LABEL # undef ZEND_VM_SPEC_LABEL
# undef ZEND_VM_SPEC_NULL_LABEL # undef ZEND_VM_SPEC_NULL_LABEL
# undef ZEND_VM_CONTINUE_LABEL
# include "zend_vm.h" # include "zend_vm.h"
@ -1451,8 +1584,11 @@ static void old_execute(zend_op_array *op_array TSRMLS_DC)
} else { } else {
EX(Ts) = (temp_variable *) safe_emalloc(sizeof(temp_variable), op_array->T, 0); 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(op_array) = op_array;
EX(original_in_execution) = EG(in_execution); EX(original_in_execution) = EG(in_execution);
EX(symbol_table) = EG(active_symbol_table);
EX(prev_execute_data) = EG(current_execute_data); EX(prev_execute_data) = EG(current_execute_data);
EG(current_execute_data) = &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, /* 5 */
_UNUSED_CODE, /* 6 */ _UNUSED_CODE, /* 6 */
_UNUSED_CODE, /* 7 */ _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: * Local variables:

2
Zend/zend_language_parser.y
View file

@ -771,7 +771,7 @@ variable_without_objects:
; ;
static_member: 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->opcodes = NULL;
op_array_alloc_ops(op_array); 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->T = 0;
op_array->function_name = NULL; 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); 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) { while (opline<end) {
if (opline->op1.op_type==IS_CONST) { if (opline->op1.op_type==IS_CONST) {
#if DEBUG_ZEND>2 #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 _TMP_CODE 1
#define _VAR_CODE 2 #define _VAR_CODE 2
#define _UNUSED_CODE 3 #define _UNUSED_CODE 3
#define _CV_CODE 4
#ifndef ZEND_VM_KIND #ifndef ZEND_VM_KIND
# ifdef __GNUC__ # ifdef __GNUC__
@ -81,11 +82,19 @@ static const int zend_vm_decode[] = {
_UNUSED_CODE, /* 5 */ _UNUSED_CODE, /* 5 */
_UNUSED_CODE, /* 6 */ _UNUSED_CODE, /* 6 */
_UNUSED_CODE, /* 7 */ _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) \ # 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) \ # define ZEND_VM_SPEC_OPCODE(opcode, op1, op2) \
ZEND_VM_CODE(opcode, zend_vm_decode[op1], zend_vm_decode[op2]) ZEND_VM_CODE(opcode, zend_vm_decode[op1], zend_vm_decode[op2])
# ifdef ZEND_VM_HAVE_OLD_EXECUTOR # ifdef ZEND_VM_HAVE_OLD_EXECUTOR
@ -173,6 +182,7 @@ static const int zend_vm_decode[] = {
} }
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \ free_alloca(EX(Ts)); \
} else { \ } else { \
@ -267,6 +277,7 @@ static const int zend_vm_decode[] = {
} }
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \ free_alloca(EX(Ts)); \
} else { \ } else { \
@ -358,6 +369,7 @@ static const int zend_vm_decode[] = {
} }
# define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \ # define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
free_alloca(EX(CVs)); \
if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \ if (EX(op_array)->T < TEMP_VAR_STACK_LIMIT) { \
free_alloca(EX(Ts)); \ free_alloca(EX(Ts)); \
} else { \ } else { \

272
Zend/zend_vm_handlers.h
View file

File diff suppressed because it is too large Load diff

344
Zend/zend_vm_spec.h
View file

@ -83,114 +83,133 @@
#define SPEC__TMP_CODE _TMP_CODE #define SPEC__TMP_CODE _TMP_CODE
#define SPEC__VAR_CODE _VAR_CODE #define SPEC__VAR_CODE _VAR_CODE
#define SPEC__UNUSED_CODE _UNUSED_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_ANY opline->op1.op_type
#define SPEC_OP1_TYPE_CONST IS_CONST #define SPEC_OP1_TYPE_CONST IS_CONST
#define SPEC_OP1_TYPE_TMP IS_TMP_VAR #define SPEC_OP1_TYPE_TMP IS_TMP_VAR
#define SPEC_OP1_TYPE_VAR IS_VAR #define SPEC_OP1_TYPE_VAR IS_VAR
#define SPEC_OP1_TYPE_UNUSED IS_UNUSED #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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_ANY() IS_TMP_FREE(free_op1)
#define SPEC_IS_OP1_TMP_FREE_CONST() 0 #define SPEC_IS_OP1_TMP_FREE_CONST() 0
#define SPEC_IS_OP1_TMP_FREE_TMP() 1 #define SPEC_IS_OP1_TMP_FREE_TMP() 1
#define SPEC_IS_OP1_TMP_FREE_VAR() 0 #define SPEC_IS_OP1_TMP_FREE_VAR() 0
#define SPEC_IS_OP1_TMP_FREE_UNUSED() 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_ANY() FREE_OP(free_op1);
#define SPEC_FREE_OP1_CONST() #define SPEC_FREE_OP1_CONST()
#define SPEC_FREE_OP1_TMP() zval_dtor(free_op1.var) #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_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_UNUSED() #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_ANY() FREE_OP_IF_VAR(free_op1);
#define SPEC_FREE_OP1_IF_VAR_CONST() #define SPEC_FREE_OP1_IF_VAR_CONST()
#define SPEC_FREE_OP1_IF_VAR_TMP() #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_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_IF_VAR_UNUSED() #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_ANY() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_VAR_PTR_CONST() #define SPEC_FREE_OP1_VAR_PTR_CONST()
#define SPEC_FREE_OP1_VAR_PTR_TMP() #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_VAR() FREE_OP_VAR_PTR(free_op1);
#define SPEC_FREE_OP1_VAR_PTR_UNUSED() #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_ANY opline->op2.op_type
#define SPEC_OP2_TYPE_CONST IS_CONST #define SPEC_OP2_TYPE_CONST IS_CONST
#define SPEC_OP2_TYPE_TMP IS_TMP_VAR #define SPEC_OP2_TYPE_TMP IS_TMP_VAR
#define SPEC_OP2_TYPE_VAR IS_VAR #define SPEC_OP2_TYPE_VAR IS_VAR
#define SPEC_OP2_TYPE_UNUSED IS_UNUSED #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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_ANY() IS_TMP_FREE(free_op2)
#define SPEC_IS_OP2_TMP_FREE_CONST() 0 #define SPEC_IS_OP2_TMP_FREE_CONST() 0
#define SPEC_IS_OP2_TMP_FREE_TMP() 1 #define SPEC_IS_OP2_TMP_FREE_TMP() 1
#define SPEC_IS_OP2_TMP_FREE_VAR() 0 #define SPEC_IS_OP2_TMP_FREE_VAR() 0
#define SPEC_IS_OP2_TMP_FREE_UNUSED() 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_ANY() FREE_OP(free_op2);
#define SPEC_FREE_OP2_CONST() #define SPEC_FREE_OP2_CONST()
#define SPEC_FREE_OP2_TMP() zval_dtor(free_op2.var) #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_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_UNUSED() #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_ANY() FREE_OP_IF_VAR(free_op2);
#define SPEC_FREE_OP2_IF_VAR_CONST() #define SPEC_FREE_OP2_IF_VAR_CONST()
#define SPEC_FREE_OP2_IF_VAR_TMP() #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_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_IF_VAR_UNUSED() #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_ANY() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_VAR_PTR_CONST() #define SPEC_FREE_OP2_VAR_PTR_CONST()
#define SPEC_FREE_OP2_VAR_PTR_TMP() #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_VAR() FREE_OP_VAR_PTR(free_op2);
#define SPEC_FREE_OP2_VAR_PTR_UNUSED() #define SPEC_FREE_OP2_VAR_PTR_UNUSED()
#define SPEC_FREE_OP2_VAR_PTR_CV()
#ifndef ZEND_VM_SPEC #ifndef ZEND_VM_SPEC
@ -224,6 +243,22 @@
# define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED) # define M_TMP_UNUSED (IS_TMP_VAR|IS_UNUSED)
# define M_TMP_VAR_UNUSED (IS_TMP_VAR|IS_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_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) \ # define OP1_OP2_MASK(OP1T, OP2T) \
((OP1 & (OP1T)) && (OP2 & (OP2T))) ((OP1 & (OP1T)) && (OP2 & (OP2T)))
@ -334,6 +369,12 @@
# define OP2 IS_ANY # define OP2 IS_ANY
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_ANY # define OP1 IS_ANY
@ -358,6 +399,12 @@
# define OP2 IS_UNUSED # define OP2 IS_UNUSED
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_UNUSED # define OP1 IS_UNUSED
@ -382,6 +429,12 @@
# define OP2 IS_VAR # define OP2 IS_VAR
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_CONST # define OP1 IS_CONST
@ -400,6 +453,12 @@
# define OP2 IS_UNUSED # define OP2 IS_UNUSED
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_CONST # define OP1 IS_CONST
@ -418,6 +477,12 @@
# define OP2 IS_VAR # define OP2 IS_VAR
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_TMP_VAR # define OP1 IS_TMP_VAR
@ -436,6 +501,12 @@
# define OP2 IS_VAR # define OP2 IS_VAR
# include "zend_vm_handlers.h" # 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 OP1
# undef OP2 # undef OP2
# define OP1 IS_VAR # define OP1 IS_VAR
@ -454,6 +525,36 @@
# define OP2 IS_VAR # define OP2 IS_VAR
# include "zend_vm_handlers.h" # 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 */ /* LABELS */
# undef M_ANY # undef M_ANY
@ -472,6 +573,22 @@
# undef M_TMP_UNUSED # undef M_TMP_UNUSED
# undef M_TMP_VAR_UNUSED # undef M_TMP_VAR_UNUSED
# undef M_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 # undef OPDEF
@ -479,92 +596,160 @@
SPEC_LABELS1_##OP1M(OP##_SPEC, OP, OP2M) SPEC_LABELS1_##OP1M(OP##_SPEC, OP, OP2M)
# define SPEC_LABELS1_M_ANY(OP, CODE, 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # 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) \ # define SPEC_LABELS1_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP2M) \
SPEC_LABELS2_##OP2M(OP, CODE, _CONST, _TMP, _VAR, _UNUSED) 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) \ # define SPEC_LABELS2_M_ANY(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _ANY, _ANY, _ANY, _ANY) 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) \ # define SPEC_LABELS2_M_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _NULL, _UNUSED) 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) \ # define SPEC_LABELS2_M_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _NULL) 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) \ # define SPEC_LABELS2_M_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _NULL, _VAR, _UNUSED) 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) \ # define SPEC_LABELS2_M_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _NULL) 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) \ # define SPEC_LABELS2_M_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _NULL, _UNUSED) 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) \ # define SPEC_LABELS2_M_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _NULL) 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) \ # define SPEC_LABELS2_M_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _NULL, _TMP, _VAR, _UNUSED) 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) \ # define SPEC_LABELS2_M_CONST(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _NULL) 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) \ # define SPEC_LABELS2_M_CONST_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _NULL, _UNUSED) 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) \ # define SPEC_LABELS2_M_CONST_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _NULL) 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) \ # define SPEC_LABELS2_M_CONST_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _NULL, _VAR, _UNUSED) 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) \ # define SPEC_LABELS2_M_CONST_TMP(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _NULL) 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) \ # define SPEC_LABELS2_M_CONST_TMP_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _NULL, _UNUSED) 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) \ # define SPEC_LABELS2_M_CONST_TMP_VAR(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _NULL) 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) \ # define SPEC_LABELS2_M_CONST_TMP_VAR_UNUSED(OP, CODE, OP1C, OP1T, OP1V, OP1U, OP1X) \
SPEC_LABELS(OP, CODE, OP1C, OP1T, OP1V, OP1U, _CONST, _TMP, _VAR, _UNUSED) 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) \ # define LABELS_1(OP,CODE,OP1,OP2C,OP2T,OP2V,OP2U,OP2X) \
OP1##OP2C(OP,CODE), \ OP1##OP2C(OP,CODE), \
OP1##OP2T(OP,CODE), \ OP1##OP2T(OP,CODE), \
OP1##OP2V(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) \ # 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), \ LABELS_1(OP,CODE,SPEC_LABEL##OP1C,OP2C,OP2T,OP2V,OP2U,OP2X), \
LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U), \ LABELS_1(OP,CODE,SPEC_LABEL##OP1T,OP2C,OP2T,OP2V,OP2U,OP2X), \
LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U), \ LABELS_1(OP,CODE,SPEC_LABEL##OP1V,OP2C,OP2T,OP2V,OP2U,OP2X), \
LABELS_1(OP,CODE,SPEC_LABEL##OP1U,OP2C,OP2T,OP2V,OP2U) 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_CONST_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_TMP_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_VAR_NULL(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_UNUSED_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_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_CONST(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_TMP(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_VAR(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_UNUSED(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_ANY(OP,CODE) ZEND_VM_SPEC_NULL_LABEL
# define SPEC_LABEL_NULL_NULL(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) \ # 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)) ZEND_VM_SPEC_LABEL(OP##_ANY_VAR, ZEND_VM_CODE(CODE, _ANY_CODE, _VAR_CODE))
# define SPEC_LABEL_ANY_UNUSED(OP,CODE) \ # define SPEC_LABEL_ANY_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_ANY_UNUSED, ZEND_VM_CODE(CODE, _ANY_CODE, _UNUSED_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) \ # define SPEC_LABEL_CONST_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_CONST_ANY, ZEND_VM_CODE(CODE, _CONST_CODE, _ANY_CODE)) ZEND_VM_SPEC_LABEL(OP##_CONST_ANY, ZEND_VM_CODE(CODE, _CONST_CODE, _ANY_CODE))
# define SPEC_LABEL_CONST_CONST(OP,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)) ZEND_VM_SPEC_LABEL(OP##_CONST_VAR, ZEND_VM_CODE(CODE, _CONST_CODE, _VAR_CODE))
# define SPEC_LABEL_CONST_UNUSED(OP,CODE) \ # define SPEC_LABEL_CONST_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_CONST_UNUSED, ZEND_VM_CODE(CODE, _CONST_CODE, _UNUSED_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) \ # define SPEC_LABEL_TMP_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_TMP_ANY, ZEND_VM_CODE(CODE, _TMP_CODE, _ANY_CODE)) ZEND_VM_SPEC_LABEL(OP##_TMP_ANY, ZEND_VM_CODE(CODE, _TMP_CODE, _ANY_CODE))
# define SPEC_LABEL_TMP_CONST(OP,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)) ZEND_VM_SPEC_LABEL(OP##_TMP_VAR, ZEND_VM_CODE(CODE, _TMP_CODE, _VAR_CODE))
# define SPEC_LABEL_TMP_UNUSED(OP,CODE) \ # define SPEC_LABEL_TMP_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_TMP_UNUSED, ZEND_VM_CODE(CODE, _TMP_CODE, _UNUSED_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) \ # define SPEC_LABEL_VAR_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_VAR_ANY, ZEND_VM_CODE(CODE, _VAR_CODE, _ANY_CODE)) ZEND_VM_SPEC_LABEL(OP##_VAR_ANY, ZEND_VM_CODE(CODE, _VAR_CODE, _ANY_CODE))
# define SPEC_LABEL_VAR_CONST(OP,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)) ZEND_VM_SPEC_LABEL(OP##_VAR_VAR, ZEND_VM_CODE(CODE, _VAR_CODE, _VAR_CODE))
# define SPEC_LABEL_VAR_UNUSED(OP,CODE) \ # define SPEC_LABEL_VAR_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_VAR_UNUSED, ZEND_VM_CODE(CODE, _VAR_CODE, _UNUSED_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) \ # define SPEC_LABEL_UNUSED_ANY(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_UNUSED_ANY, ZEND_VM_CODE(CODE, _UNUSED_CODE, _ANY_CODE)) ZEND_VM_SPEC_LABEL(OP##_UNUSED_ANY, ZEND_VM_CODE(CODE, _UNUSED_CODE, _ANY_CODE))
# define SPEC_LABEL_UNUSED_CONST(OP,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)) ZEND_VM_SPEC_LABEL(OP##_UNUSED_VAR, ZEND_VM_CODE(CODE, _UNUSED_CODE, _VAR_CODE))
# define SPEC_LABEL_UNUSED_UNUSED(OP,CODE) \ # define SPEC_LABEL_UNUSED_UNUSED(OP,CODE) \
ZEND_VM_SPEC_LABEL(OP##_UNUSED_UNUSED, ZEND_VM_CODE(CODE, _UNUSED_CODE, _UNUSED_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 # undef ZEND_VM_NULL_LABEL
# define 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, \
ZEND_VM_SPEC_NULL_LABEL, \
ZEND_VM_SPEC_NULL_LABEL, \
ZEND_VM_SPEC_NULL_LABEL ZEND_VM_SPEC_NULL_LABEL
# undef ZEND_VM_LABEL # undef ZEND_VM_LABEL
@ -643,7 +859,7 @@
#endif #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(); ZEND_VM_NULL_HANDLER();
#else #else
ZEND_VM_NULL_HANDLER() 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; zval *session_vars = NULL;
/* Unconditionally destroy existing arrays -- possible dirty data */ /* Unconditionally destroy existing arrays -- possible dirty data */
zend_hash_del(&EG(symbol_table), "HTTP_SESSION_VARS", delete_global_variable("HTTP_SESSION_VARS", sizeof("HTTP_SESSION_VARS")-1 TSRMLS_CC);
sizeof("HTTP_SESSION_VARS")); delete_global_variable("_SESSION", sizeof("_SESSION")-1 TSRMLS_CC);
zend_hash_del(&EG(symbol_table), "_SESSION", sizeof("_SESSION"));
MAKE_STD_ZVAL(session_vars); MAKE_STD_ZVAL(session_vars);
array_init(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, while (zend_hash_get_current_key_ex(ht, &str, &str_len, &num_key,
0, &pos) == HASH_KEY_IS_STRING) { 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); zend_hash_move_forward_ex(ht, &pos);
} }
} }

6
ext/spl/spl_array.c
View file

@ -278,9 +278,15 @@ static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC)
switch(Z_TYPE_P(offset)) { switch(Z_TYPE_P(offset)) {
case IS_STRING: case IS_STRING:
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) { 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)); zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
} }
}
return; return;
case IS_DOUBLE: case IS_DOUBLE:
case IS_RESOURCE: case IS_RESOURCE:

8
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 */ /* Delete the first or last value */
zend_hash_get_current_key_ex(Z_ARRVAL_PP(stack), &key, &key_len, &index, 0, NULL); zend_hash_get_current_key_ex(Z_ARRVAL_PP(stack), &key, &key_len, &index, 0, NULL);
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); 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 we did a shift... re-index like it did before */
if (!off_the_end) { if (!off_the_end) {
@ -2761,7 +2765,11 @@ PHP_FUNCTION(array_unique)
p = cmpdata->b; p = cmpdata->b;
} }
if (p->nKeyLength) { if (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); zend_hash_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength);
}
} else { } else {
zend_hash_index_del(Z_ARRVAL_P(return_value), p->h); 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, prefix_len);
memcpy(new_key+prefix_len, hash_key->arKey, hash_key->nKeyLength); 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); ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), new_key, new_key_len, *var, (*var)->refcount+1, 0);
efree(new_key); efree(new_key);