mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-01-04 18:03:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Implemented concept of "delayed early binding" that allows opcode caches to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php.

Browse Source 
The following pseudo-code explains how it should be used in opcode cache.

function cache_compile_file($filename) {
        if (!is_cached($filename)) {
                ...
                orig_compiler_options = CG(compiler_optins);
                CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES |
                                        ZEND_COMPILE_DELAYED_BINDING;
                $op_array = orig_compile_file($filename);
                CG(compiler_options) = orig_copiler_options;
                ...
        } else {
                $op_array = restore_from_cache($filename);
        }
        zend_do_delayed_early_binding($op_array);
}
This commit is contained in:
Dmitry Stogov 2008-03-18 08:36:49 +00:00
parent a0378d3514
commit ea9305c543
12 changed files with 295 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Zend/zend.c
View File

@ -688,13 +688,13 @@ static void register_standard_class(TSRMLS_D) /* {{{ */
/* }}} */ /* }}} */
#ifdef ZTS #ifdef ZTS
static zend_bool asp_tags_default = 0; static zend_bool asp_tags_default = 0;
static zend_bool short_tags_default = 1; static zend_bool short_tags_default = 1;
static zend_bool extended_info_default = 0; static zend_uint compiler_options_default = ZEND_COMPILE_DEFAULT;
#else #else
# define asp_tags_default 0 # define asp_tags_default 0
# define short_tags_default 1 # define short_tags_default 1
# define extended_info_default 0 # define compiler_options_default ZEND_COMPILE_DEFAULT
#endif #endif
static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */ static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */
@ -702,7 +702,7 @@ static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */
/* default compile-time values */ /* default compile-time values */
CG(asp_tags) = asp_tags_default; CG(asp_tags) = asp_tags_default;
CG(short_tags) = short_tags_default; CG(short_tags) = short_tags_default;
CG(extended_info) = extended_info_default; CG(compiler_options) = compiler_options_default;
CG(literal_type) = ZEND_STR_TYPE; CG(literal_type) = ZEND_STR_TYPE;
} }
/* }}} */ /* }}} */
@ -1194,7 +1194,7 @@ void zend_post_startup(TSRMLS_D) /* {{{ */
asp_tags_default = CG(asp_tags); asp_tags_default = CG(asp_tags);
short_tags_default = CG(short_tags); short_tags_default = CG(short_tags);
extended_info_default = CG(extended_info); compiler_options_default = CG(compiler_options);
zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC); zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC);
free(compiler_globals->function_table); free(compiler_globals->function_table);

117
Zend/zend_compile.c
View File

@ -159,7 +159,6 @@ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
zend_stack_init(&CG(list_stack)); zend_stack_init(&CG(list_stack));
CG(handle_op_arrays) = 1;
CG(in_compilation) = 0; CG(in_compilation) = 0;
CG(start_lineno) = 0; CG(start_lineno) = 0;
init_compiler_declarables(TSRMLS_C); init_compiler_declarables(TSRMLS_C);
@ -1324,7 +1323,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
zend_u_hash_update(CG(function_table), Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)); zend_u_hash_update(CG(function_table), Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
} }
if (CG(extended_info)) { if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_EXT_NOP; opline->opcode = ZEND_EXT_NOP;
@ -1537,7 +1536,9 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace
} }
lcname = zend_u_str_case_fold(Z_TYPE(function_name->u.constant), Z_UNIVAL(function_name->u.constant), Z_UNILEN(function_name->u.constant), 0, &lcname_len); lcname = zend_u_str_case_fold(Z_TYPE(function_name->u.constant), Z_UNIVAL(function_name->u.constant), Z_UNILEN(function_name->u.constant), 0, &lcname_len);
if (zend_u_hash_find(CG(function_table), Z_TYPE(function_name->u.constant), lcname, lcname_len+1, (void **) &function)==FAILURE) { if ((zend_u_hash_find(CG(function_table), Z_TYPE(function_name->u.constant), lcname, lcname_len+1, (void **) &function)==FAILURE) ||
((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
(function->type == ZEND_INTERNAL_FUNCTION))) {
zend_do_begin_dynamic_function_call(function_name, prefix_len TSRMLS_CC); zend_do_begin_dynamic_function_call(function_name, prefix_len TSRMLS_CC);
efree(lcname.v); efree(lcname.v);
return 1; /* Dynamic */ return 1; /* Dynamic */
@ -1762,8 +1763,9 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_
efree(ns_lcname.v); efree(ns_lcname.v);
} }
if (zend_u_hash_find(CG(class_table), Z_TYPE(class_name->u.constant), lcname, lcname_len+1, (void**)&pce) == SUCCESS && if ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) ||
(*pce)->type == ZEND_INTERNAL_CLASS) { (zend_u_hash_find(CG(class_table), Z_TYPE(class_name->u.constant), lcname, lcname_len+1, (void**)&pce) == SUCCESS &&
(*pce)->type == ZEND_INTERNAL_CLASS)) {
/* There is an internal class with the same name exists. /* There is an internal class with the same name exists.
PHP will need to perform additional cheks at run-time to PHP will need to perform additional cheks at run-time to
determine if we assume class in current namespace or determine if we assume class in current namespace or
@ -2970,7 +2972,6 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
{ {
zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1]; zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
HashTable *table; HashTable *table;
zend_bool is_abstract_class = 0;
while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) { while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
opline--; opline--;
@ -2984,57 +2985,44 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
table = CG(function_table); table = CG(function_table);
break; break;
case ZEND_DECLARE_CLASS: case ZEND_DECLARE_CLASS:
if (do_bind_class(opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
return;
}
table = CG(class_table);
break;
case ZEND_DECLARE_INHERITED_CLASS: case ZEND_DECLARE_INHERITED_CLASS:
is_abstract_class = 1; {
/* break missing intentionally */ zend_op *fetch_class_opline = opline-1;
case ZEND_VERIFY_ABSTRACT_CLASS: { zval *parent_name = &fetch_class_opline->op2.u.constant;
zend_op *verify_abstract_class_op = opline; zend_class_entry **pce;
if (!is_abstract_class) { if ((zend_u_lookup_class(Z_TYPE_P(parent_name), Z_UNIVAL_P(parent_name), Z_UNILEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) ||
opline--; ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
} ((*pce)->type == ZEND_INTERNAL_CLASS))) {
if (opline->opcode == ZEND_DECLARE_CLASS) { if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
if (do_bind_class(opline, CG(class_table), 1 TSRMLS_CC) == NULL) { zend_uint *opline_num = &CG(active_op_array)->early_binding;
return;
}
} else if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS) {
zval *parent_name = &(opline-1)->op2.u.constant;
zend_class_entry **pce;
if (zend_u_lookup_class(Z_TYPE_P(parent_name), Z_UNIVAL_P(parent_name), Z_UNILEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) { while (*opline_num != -1) {
return; opline_num = &CG(active_op_array)->opcodes[*opline_num].result.u.opline_num;
}
*opline_num = opline - CG(active_op_array)->opcodes;
opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
opline->result.op_type = IS_UNUSED;
opline->result.u.opline_num = -1;
} }
if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
return;
}
/* clear unnecessary ZEND_FETCH_CLASS opcode */
if (opline > CG(active_op_array)->opcodes &&
(opline-1)->opcode == ZEND_FETCH_CLASS) {
zend_op *fetch_class_opline = opline-1;
zval_dtor(&fetch_class_opline->op2.u.constant);
fetch_class_opline->opcode = ZEND_NOP;
memset(&fetch_class_opline->op1, 0, sizeof(znode));
memset(&fetch_class_opline->op2, 0, sizeof(znode));
SET_UNUSED(fetch_class_opline->op1);
SET_UNUSED(fetch_class_opline->op2);
SET_UNUSED(fetch_class_opline->result);
}
} else {
/* We currently don't early-bind classes that implement interfaces */
return; return;
} }
table = CG(class_table); if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
if (!is_abstract_class) { return;
/* clear the verify_abstract_class op */
init_op(verify_abstract_class_op TSRMLS_CC);
SET_UNUSED(verify_abstract_class_op->op1);
SET_UNUSED(verify_abstract_class_op->op2);
verify_abstract_class_op->opcode = ZEND_NOP;
} }
} /* clear unnecessary ZEND_FETCH_CLASS opcode */
zval_dtor(&fetch_class_opline->op2.u.constant);
MAKE_NOP(fetch_class_opline);
break; table = CG(class_table);
break;
}
case ZEND_VERIFY_ABSTRACT_CLASS:
case ZEND_ADD_INTERFACE: case ZEND_ADD_INTERFACE:
/* We currently don't early-bind classes that implement interfaces */ /* We currently don't early-bind classes that implement interfaces */
return; return;
@ -3046,11 +3034,26 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
zend_u_hash_del(table, Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant)); zend_u_hash_del(table, Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant));
zval_dtor(&opline->op1.u.constant); zval_dtor(&opline->op1.u.constant);
zval_dtor(&opline->op2.u.constant); zval_dtor(&opline->op2.u.constant);
opline->opcode = ZEND_NOP; MAKE_NOP(opline);
memset(&opline->op1, 0, sizeof(znode)); }
memset(&opline->op2, 0, sizeof(znode)); /* }}} */
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2); ZEND_API void zend_do_delayed_early_binding(zend_op_array *op_array TSRMLS_DC) /* {{{ */
{
if (op_array->early_binding != -1) {
zend_bool orig_in_compilation = CG(in_compilation);
zend_uint opline_num = op_array->early_binding;
zend_class_entry **pce;
CG(in_compilation) = 1;
while (opline_num != -1) {
if (zend_u_lookup_class(Z_TYPE(op_array->opcodes[opline_num-1].op2.u.constant), Z_UNIVAL(op_array->opcodes[opline_num-1].op2.u.constant), Z_UNILEN(op_array->opcodes[opline_num-1].op2.u.constant), &pce TSRMLS_CC) == SUCCESS) {
do_bind_inherited_class(&op_array->opcodes[opline_num], EG(class_table), *pce, 1 TSRMLS_CC);
}
opline_num = op_array->opcodes[opline_num].result.u.opline_num;
}
CG(in_compilation) = orig_in_compilation;
}
} }
/* }}} */ /* }}} */
@ -4852,7 +4855,7 @@ void zend_do_extended_info(TSRMLS_D) /* {{{ */
{ {
zend_op *opline; zend_op *opline;
if (!CG(extended_info)) { if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return; return;
} }
@ -4868,7 +4871,7 @@ void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
{ {
zend_op *opline; zend_op *opline;
if (!CG(extended_info)) { if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return; return;
} }
@ -4884,7 +4887,7 @@ void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
{ {
zend_op *opline; zend_op *opline;
if (!CG(extended_info)) { if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return; return;
} }

28
Zend/zend_compile.h
View File

@ -229,6 +229,7 @@ struct _zend_op_array {
zend_uint line_end; zend_uint line_end;
zstr doc_comment; zstr doc_comment;
zend_uint doc_comment_len; zend_uint doc_comment_len;
zend_uint early_binding; /* the linked list of delayed declarations */
void *reserved[ZEND_MAX_RESERVED_RESOURCES]; void *reserved[ZEND_MAX_RESERVED_RESOURCES];
}; };
@ -440,6 +441,7 @@ void zend_do_implements_interface(znode *interface_znode TSRMLS_DC);
ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC); ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC);
void zend_do_early_binding(TSRMLS_D); void zend_do_early_binding(TSRMLS_D);
ZEND_API void zend_do_delayed_early_binding(zend_op_array *op_array TSRMLS_DC);
void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC); void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC);
@ -759,6 +761,32 @@ END_EXTERN_C()
#define ZEND_HALT_CONSTANT_NAME "__COMPILER_HALT_OFFSET__" #define ZEND_HALT_CONSTANT_NAME "__COMPILER_HALT_OFFSET__"
/* The following constants may be combined in CG(compiler_options)
* to change the default compiler behavior */
/* generate extended debug information */
#define ZEND_COMPILE_EXTENDED_INFO (1<<0)
/* call op_array handler of extendions */
#define ZEND_COMPILE_HANDLE_OP_ARRAY (1<<1)
/* generate ZEND_DO_FCALL_BY_NAME for internal functions instead of ZEND_DO_FCALL */
#define ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS (1<<2)
/* don't perform early binding for classes inherited form internal ones;
* in namespaces assume that internal class that doesn't exist at compile-time
* may apper in run-time */
#define ZEND_COMPILE_IGNORE_INTERNAL_CLASSES (1<<3)
/* generate ZEND_DECLARE_INHERITED_CLASS_DELAYED opcode to delay early binding */
#define ZEND_COMPILE_DELAYED_BINDING (1<<4)
/* The default value for CG(compiler_options) */
#define ZEND_COMPILE_DEFAULT ZEND_COMPILE_HANDLE_OP_ARRAY
/* The default value for CG(compiler_options) during eval() */
#define ZEND_COMPILE_DEFAULT_FOR_EVAL 0
#endif /* ZEND_COMPILE_H */ #endif /* ZEND_COMPILE_H */
/* /*

8
Zend/zend_execute_API.c
View File

@ -1409,7 +1409,7 @@ ZEND_API int zend_u_eval_string(zend_uchar type, zstr string, zval *retval_ptr,
zval pv; zval pv;
zend_op_array *new_op_array; zend_op_array *new_op_array;
zend_op_array *original_active_op_array = EG(active_op_array); zend_op_array *original_active_op_array = EG(active_op_array);
zend_uchar original_handle_op_arrays; zend_uint original_compiler_options;
int retval; int retval;
if (type == IS_UNICODE) { if (type == IS_UNICODE) {
@ -1443,10 +1443,10 @@ ZEND_API int zend_u_eval_string(zend_uchar type, zstr string, zval *retval_ptr,
/*printf("Evaluating '%s'\n", Z_STRVAL(pv));*/ /*printf("Evaluating '%s'\n", Z_STRVAL(pv));*/
original_handle_op_arrays = CG(handle_op_arrays); original_compiler_options = CG(compiler_options);
CG(handle_op_arrays) = 0; CG(compiler_options) = ZEND_COMPILE_DEFAULT_FOR_EVAL;
new_op_array = zend_compile_string(&pv, string_name TSRMLS_CC); new_op_array = zend_compile_string(&pv, string_name TSRMLS_CC);
CG(handle_op_arrays) = original_handle_op_arrays; CG(compiler_options) = original_compiler_options;
if (new_op_array) { if (new_op_array) {
zval *local_retval_ptr=NULL; zval *local_retval_ptr=NULL;

6
Zend/zend_globals.h
View File

@ -105,10 +105,6 @@ struct _zend_compiler_globals {
zend_declarables declarables; zend_declarables declarables;
/* For extensions support */
zend_bool extended_info; /* generate extension information for debugger/profiler */
zend_bool handle_op_arrays; /* run op_arrays through op_array handlers */
zend_bool unclean_shutdown; zend_bool unclean_shutdown;
zend_bool ini_parser_unbuffered_errors; zend_bool ini_parser_unbuffered_errors;
@ -139,6 +135,8 @@ struct _zend_compiler_globals {
HashTable *labels; HashTable *labels;
zend_stack labels_stack; zend_stack labels_stack;
zend_uint compiler_options; /* set of ZEND_COMPILE_* constants */
zval *current_namespace; zval *current_namespace;
HashTable *current_import; HashTable *current_import;

6
Zend/zend_opcode.c
View File

@ -107,6 +107,8 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz
op_array->fn_flags = CG(interactive)?ZEND_ACC_INTERACTIVE:0; op_array->fn_flags = CG(interactive)?ZEND_ACC_INTERACTIVE:0;
op_array->early_binding = -1;
memset(op_array->reserved, 0, ZEND_MAX_RESERVED_RESOURCES * sizeof(void*)); memset(op_array->reserved, 0, ZEND_MAX_RESERVED_RESOURCES * sizeof(void*));
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_ctor_handler, op_array TSRMLS_CC); zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_ctor_handler, op_array TSRMLS_CC);
@ -413,10 +415,10 @@ int pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */
if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) { if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
return 0; return 0;
} }
if (CG(extended_info)) { if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
zend_update_extended_info(op_array TSRMLS_CC); zend_update_extended_info(op_array TSRMLS_CC);
} }
if (CG(handle_op_arrays)) { if (CG(compiler_options) & ZEND_COMPILE_HANDLE_OP_ARRAY) {
zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_handler, op_array TSRMLS_CC); zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_handler, op_array TSRMLS_CC);
} }

13
Zend/zend_vm_def.h
View File

@ -4130,6 +4130,19 @@ ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
{
zend_op *opline = EX(opline);
zend_class_entry **pce, **pce_orig;
if (zend_hash_find(EG(class_table), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&pce) == FAILURE ||
(zend_hash_find(EG(class_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
*pce != *pce_orig)) {
do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
}
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY) ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
{ {
do_bind_function(EX(opline), EG(function_table), 0); do_bind_function(EX(opline), EG(function_table), 0);

63
Zend/zend_vm_execute.h
View File

@ -490,6 +490,19 @@ static int ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZEND_VM_NEXT_OPCODE(); ZEND_VM_NEXT_OPCODE();
} }
static int ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
zend_class_entry **pce, **pce_orig;
if (zend_hash_find(EG(class_table), Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void**)&pce) == FAILURE ||
(zend_hash_find(EG(class_table), Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant), (void**)&pce_orig) == SUCCESS &&
*pce != *pce_orig)) {
do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
}
ZEND_VM_NEXT_OPCODE();
}
static int ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{ {
do_bind_function(EX(opline), EG(function_table), 0); do_bind_function(EX(opline), EG(function_table), 0);
@ -34141,31 +34154,31 @@ void zend_init_opcodes_handlers(void)
ZEND_NULL_HANDLER, ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER, ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER, ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER, ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,

269
Zend/zend_vm_opcodes.h
View File

@ -18,137 +18,138 @@
+----------------------------------------------------------------------+ +----------------------------------------------------------------------+
*/ */
#define ZEND_NOP 0 #define ZEND_NOP 0
#define ZEND_ADD 1 #define ZEND_ADD 1
#define ZEND_SUB 2 #define ZEND_SUB 2
#define ZEND_MUL 3 #define ZEND_MUL 3
#define ZEND_DIV 4 #define ZEND_DIV 4
#define ZEND_MOD 5 #define ZEND_MOD 5
#define ZEND_SL 6 #define ZEND_SL 6
#define ZEND_SR 7 #define ZEND_SR 7
#define ZEND_CONCAT 8 #define ZEND_CONCAT 8
#define ZEND_BW_OR 9 #define ZEND_BW_OR 9
#define ZEND_BW_AND 10 #define ZEND_BW_AND 10
#define ZEND_BW_XOR 11 #define ZEND_BW_XOR 11
#define ZEND_BW_NOT 12 #define ZEND_BW_NOT 12
#define ZEND_BOOL_NOT 13 #define ZEND_BOOL_NOT 13
#define ZEND_BOOL_XOR 14 #define ZEND_BOOL_XOR 14
#define ZEND_IS_IDENTICAL 15 #define ZEND_IS_IDENTICAL 15
#define ZEND_IS_NOT_IDENTICAL 16 #define ZEND_IS_NOT_IDENTICAL 16
#define ZEND_IS_EQUAL 17 #define ZEND_IS_EQUAL 17
#define ZEND_IS_NOT_EQUAL 18 #define ZEND_IS_NOT_EQUAL 18
#define ZEND_IS_SMALLER 19 #define ZEND_IS_SMALLER 19
#define ZEND_IS_SMALLER_OR_EQUAL 20 #define ZEND_IS_SMALLER_OR_EQUAL 20
#define ZEND_CAST 21 #define ZEND_CAST 21
#define ZEND_QM_ASSIGN 22 #define ZEND_QM_ASSIGN 22
#define ZEND_ASSIGN_ADD 23 #define ZEND_ASSIGN_ADD 23
#define ZEND_ASSIGN_SUB 24 #define ZEND_ASSIGN_SUB 24
#define ZEND_ASSIGN_MUL 25 #define ZEND_ASSIGN_MUL 25
#define ZEND_ASSIGN_DIV 26 #define ZEND_ASSIGN_DIV 26
#define ZEND_ASSIGN_MOD 27 #define ZEND_ASSIGN_MOD 27
#define ZEND_ASSIGN_SL 28 #define ZEND_ASSIGN_SL 28
#define ZEND_ASSIGN_SR 29 #define ZEND_ASSIGN_SR 29
#define ZEND_ASSIGN_CONCAT 30 #define ZEND_ASSIGN_CONCAT 30
#define ZEND_ASSIGN_BW_OR 31 #define ZEND_ASSIGN_BW_OR 31
#define ZEND_ASSIGN_BW_AND 32 #define ZEND_ASSIGN_BW_AND 32
#define ZEND_ASSIGN_BW_XOR 33 #define ZEND_ASSIGN_BW_XOR 33
#define ZEND_PRE_INC 34 #define ZEND_PRE_INC 34
#define ZEND_PRE_DEC 35 #define ZEND_PRE_DEC 35
#define ZEND_POST_INC 36 #define ZEND_POST_INC 36
#define ZEND_POST_DEC 37 #define ZEND_POST_DEC 37
#define ZEND_ASSIGN 38 #define ZEND_ASSIGN 38
#define ZEND_ASSIGN_REF 39 #define ZEND_ASSIGN_REF 39
#define ZEND_ECHO 40 #define ZEND_ECHO 40
#define ZEND_PRINT 41 #define ZEND_PRINT 41
#define ZEND_JMP 42 #define ZEND_JMP 42
#define ZEND_JMPZ 43 #define ZEND_JMPZ 43
#define ZEND_JMPNZ 44 #define ZEND_JMPNZ 44
#define ZEND_JMPZNZ 45 #define ZEND_JMPZNZ 45
#define ZEND_JMPZ_EX 46 #define ZEND_JMPZ_EX 46
#define ZEND_JMPNZ_EX 47 #define ZEND_JMPNZ_EX 47
#define ZEND_CASE 48 #define ZEND_CASE 48
#define ZEND_SWITCH_FREE 49 #define ZEND_SWITCH_FREE 49
#define ZEND_BRK 50 #define ZEND_BRK 50
#define ZEND_CONT 51 #define ZEND_CONT 51
#define ZEND_BOOL 52 #define ZEND_BOOL 52
#define ZEND_INIT_STRING 53 #define ZEND_INIT_STRING 53
#define ZEND_ADD_CHAR 54 #define ZEND_ADD_CHAR 54
#define ZEND_ADD_STRING 55 #define ZEND_ADD_STRING 55
#define ZEND_ADD_VAR 56 #define ZEND_ADD_VAR 56
#define ZEND_BEGIN_SILENCE 57 #define ZEND_BEGIN_SILENCE 57
#define ZEND_END_SILENCE 58 #define ZEND_END_SILENCE 58
#define ZEND_INIT_FCALL_BY_NAME 59 #define ZEND_INIT_FCALL_BY_NAME 59
#define ZEND_DO_FCALL 60 #define ZEND_DO_FCALL 60
#define ZEND_DO_FCALL_BY_NAME 61 #define ZEND_DO_FCALL_BY_NAME 61
#define ZEND_RETURN 62 #define ZEND_RETURN 62
#define ZEND_RECV 63 #define ZEND_RECV 63
#define ZEND_RECV_INIT 64 #define ZEND_RECV_INIT 64
#define ZEND_SEND_VAL 65 #define ZEND_SEND_VAL 65
#define ZEND_SEND_VAR 66 #define ZEND_SEND_VAR 66
#define ZEND_SEND_REF 67 #define ZEND_SEND_REF 67
#define ZEND_NEW 68 #define ZEND_NEW 68
#define ZEND_INIT_NS_FCALL_BY_NAME 69 #define ZEND_INIT_NS_FCALL_BY_NAME 69
#define ZEND_FREE 70 #define ZEND_FREE 70
#define ZEND_INIT_ARRAY 71 #define ZEND_INIT_ARRAY 71
#define ZEND_ADD_ARRAY_ELEMENT 72 #define ZEND_ADD_ARRAY_ELEMENT 72
#define ZEND_INCLUDE_OR_EVAL 73 #define ZEND_INCLUDE_OR_EVAL 73
#define ZEND_UNSET_VAR 74 #define ZEND_UNSET_VAR 74
#define ZEND_UNSET_DIM 75 #define ZEND_UNSET_DIM 75
#define ZEND_UNSET_OBJ 76 #define ZEND_UNSET_OBJ 76
#define ZEND_FE_RESET 77 #define ZEND_FE_RESET 77
#define ZEND_FE_FETCH 78 #define ZEND_FE_FETCH 78
#define ZEND_EXIT 79 #define ZEND_EXIT 79
#define ZEND_FETCH_R 80 #define ZEND_FETCH_R 80
#define ZEND_FETCH_DIM_R 81 #define ZEND_FETCH_DIM_R 81
#define ZEND_FETCH_OBJ_R 82 #define ZEND_FETCH_OBJ_R 82
#define ZEND_FETCH_W 83 #define ZEND_FETCH_W 83
#define ZEND_FETCH_DIM_W 84 #define ZEND_FETCH_DIM_W 84
#define ZEND_FETCH_OBJ_W 85 #define ZEND_FETCH_OBJ_W 85
#define ZEND_FETCH_RW 86 #define ZEND_FETCH_RW 86
#define ZEND_FETCH_DIM_RW 87 #define ZEND_FETCH_DIM_RW 87
#define ZEND_FETCH_OBJ_RW 88 #define ZEND_FETCH_OBJ_RW 88
#define ZEND_FETCH_IS 89 #define ZEND_FETCH_IS 89
#define ZEND_FETCH_DIM_IS 90 #define ZEND_FETCH_DIM_IS 90
#define ZEND_FETCH_OBJ_IS 91 #define ZEND_FETCH_OBJ_IS 91
#define ZEND_FETCH_FUNC_ARG 92 #define ZEND_FETCH_FUNC_ARG 92
#define ZEND_FETCH_DIM_FUNC_ARG 93 #define ZEND_FETCH_DIM_FUNC_ARG 93
#define ZEND_FETCH_OBJ_FUNC_ARG 94 #define ZEND_FETCH_OBJ_FUNC_ARG 94
#define ZEND_FETCH_UNSET 95 #define ZEND_FETCH_UNSET 95
#define ZEND_FETCH_DIM_UNSET 96 #define ZEND_FETCH_DIM_UNSET 96
#define ZEND_FETCH_OBJ_UNSET 97 #define ZEND_FETCH_OBJ_UNSET 97
#define ZEND_FETCH_DIM_TMP_VAR 98 #define ZEND_FETCH_DIM_TMP_VAR 98
#define ZEND_FETCH_CONSTANT 99 #define ZEND_FETCH_CONSTANT 99
#define ZEND_GOTO 100 #define ZEND_GOTO 100
#define ZEND_EXT_STMT 101 #define ZEND_EXT_STMT 101
#define ZEND_EXT_FCALL_BEGIN 102 #define ZEND_EXT_FCALL_BEGIN 102
#define ZEND_EXT_FCALL_END 103 #define ZEND_EXT_FCALL_END 103
#define ZEND_EXT_NOP 104 #define ZEND_EXT_NOP 104
#define ZEND_TICKS 105 #define ZEND_TICKS 105
#define ZEND_SEND_VAR_NO_REF 106 #define ZEND_SEND_VAR_NO_REF 106
#define ZEND_CATCH 107 #define ZEND_CATCH 107
#define ZEND_THROW 108 #define ZEND_THROW 108
#define ZEND_FETCH_CLASS 109 #define ZEND_FETCH_CLASS 109
#define ZEND_CLONE 110 #define ZEND_CLONE 110
#define ZEND_INIT_METHOD_CALL 112 #define ZEND_INIT_METHOD_CALL 112
#define ZEND_INIT_STATIC_METHOD_CALL 113 #define ZEND_INIT_STATIC_METHOD_CALL 113
#define ZEND_ISSET_ISEMPTY_VAR 114 #define ZEND_ISSET_ISEMPTY_VAR 114
#define ZEND_ISSET_ISEMPTY_DIM_OBJ 115 #define ZEND_ISSET_ISEMPTY_DIM_OBJ 115
#define ZEND_PRE_INC_OBJ 132 #define ZEND_PRE_INC_OBJ 132
#define ZEND_PRE_DEC_OBJ 133 #define ZEND_PRE_DEC_OBJ 133
#define ZEND_POST_INC_OBJ 134 #define ZEND_POST_INC_OBJ 134
#define ZEND_POST_DEC_OBJ 135 #define ZEND_POST_DEC_OBJ 135
#define ZEND_ASSIGN_OBJ 136 #define ZEND_ASSIGN_OBJ 136
#define ZEND_INSTANCEOF 138 #define ZEND_INSTANCEOF 138
#define ZEND_DECLARE_CLASS 139 #define ZEND_DECLARE_CLASS 139
#define ZEND_DECLARE_INHERITED_CLASS 140 #define ZEND_DECLARE_INHERITED_CLASS 140
#define ZEND_DECLARE_FUNCTION 141 #define ZEND_DECLARE_FUNCTION 141
#define ZEND_RAISE_ABSTRACT_ERROR 142 #define ZEND_RAISE_ABSTRACT_ERROR 142
#define ZEND_DECLARE_CONST 143 #define ZEND_DECLARE_CONST 143
#define ZEND_ADD_INTERFACE 144 #define ZEND_ADD_INTERFACE 144
#define ZEND_VERIFY_ABSTRACT_CLASS 146 #define ZEND_DECLARE_INHERITED_CLASS_DELAYED 145
#define ZEND_ASSIGN_DIM 147 #define ZEND_VERIFY_ABSTRACT_CLASS 146
#define ZEND_ISSET_ISEMPTY_PROP_OBJ 148 #define ZEND_ASSIGN_DIM 147
#define ZEND_HANDLE_EXCEPTION 149 #define ZEND_ISSET_ISEMPTY_PROP_OBJ 148
#define ZEND_USER_OPCODE 150 #define ZEND_HANDLE_EXCEPTION 149
#define ZEND_U_NORMALIZE 151 #define ZEND_USER_OPCODE 150
#define ZEND_JMP_SET 152 #define ZEND_U_NORMALIZE 151
#define ZEND_JMP_SET 152

2
sapi/cgi/cgi_main.c
View File

@ -1698,7 +1698,7 @@ consult the installation file that came with this distribution, or visit \n\
break; break;
case 'e': /* enable extended info output */ case 'e': /* enable extended info output */
CG(extended_info) = 1; CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
break; break;
case 'f': /* parse file */ case 'f': /* parse file */

2
sapi/cli/php_cli.c
View File

@ -837,7 +837,7 @@ int main(int argc, char *argv[])
break; break;
case 'e': /* enable extended info output */ case 'e': /* enable extended info output */
CG(extended_info) = 1; CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
break; break;
case 'F': case 'F':

2
sapi/milter/php_milter.c
View File

@ -1032,7 +1032,7 @@ int main(int argc, char *argv[])
break; break;
case 'e': /* enable extended info output */ case 'e': /* enable extended info output */
CG(extended_info) = 1; CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
break; break;
case 'f': /* parse file */ case 'f': /* parse file */