mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-01-06 19:03:31 +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

8
Zend/zend.c
View File

@ -690,11 +690,11 @@ 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);

105
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:
case ZEND_DECLARE_INHERITED_CLASS:
is_abstract_class = 1;
/* break missing intentionally */
case ZEND_VERIFY_ABSTRACT_CLASS: {
zend_op *verify_abstract_class_op = opline;
if (!is_abstract_class) {
opline--;
}
if (opline->opcode == ZEND_DECLARE_CLASS) {
if (do_bind_class(opline, CG(class_table), 1 TSRMLS_CC) == NULL) { if (do_bind_class(opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
return; return;
} }
} else if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS) { table = CG(class_table);
zval *parent_name = &(opline-1)->op2.u.constant; break;
case ZEND_DECLARE_INHERITED_CLASS:
{
zend_op *fetch_class_opline = opline-1;
zval *parent_name = &fetch_class_opline->op2.u.constant;
zend_class_entry **pce; 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) { if ((zend_u_lookup_class(Z_TYPE_P(parent_name), Z_UNIVAL_P(parent_name), Z_UNILEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) ||
((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
((*pce)->type == ZEND_INTERNAL_CLASS))) {
if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
zend_uint *opline_num = &CG(active_op_array)->early_binding;
while (*opline_num != -1) {
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;
}
return; return;
} }
if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) { if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
return; return;
} }
/* clear unnecessary ZEND_FETCH_CLASS opcode */ /* 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); zval_dtor(&fetch_class_opline->op2.u.constant);
fetch_class_opline->opcode = ZEND_NOP; MAKE_NOP(fetch_class_opline);
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;
}
table = CG(class_table);
if (!is_abstract_class) {
/* 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;
}
}
table = CG(class_table);
break; 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,

1
Zend/zend_vm_opcodes.h
View File

@ -145,6 +145,7 @@
#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_DECLARE_INHERITED_CLASS_DELAYED 145
#define ZEND_VERIFY_ABSTRACT_CLASS 146 #define ZEND_VERIFY_ABSTRACT_CLASS 146
#define ZEND_ASSIGN_DIM 147 #define ZEND_ASSIGN_DIM 147
#define ZEND_ISSET_ISEMPTY_PROP_OBJ 148 #define ZEND_ISSET_ISEMPTY_PROP_OBJ 148

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 */