Permalink
Browse files

Implemented concept of "delayed early binding" that allows opcode cac…

…hes to perform class declaration (early and/or run-time binding) in exactly the same order as vanila php.

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);
}
  • Loading branch information...
Dmitry Stogov
Dmitry Stogov committed Mar 18, 2008
1 parent 7c8ff91 commit 8c885b89130e3549297316c0769b27d9d3657902
Showing with 301 additions and 239 deletions.
  1. +3 −0 NEWS
  2. +10 −10 Zend/zend.c
  3. +60 −59 Zend/zend_compile.c
  4. +28 −0 Zend/zend_compile.h
  5. +4 −4 Zend/zend_execute_API.c
  6. +5 −4 Zend/zend_globals.h
  7. +4 −2 Zend/zend_opcode.c
  8. +13 −0 Zend/zend_vm_def.h
  9. +38 −25 Zend/zend_vm_execute.h
  10. +133 −132 Zend/zend_vm_opcodes.h
  11. +1 −1 sapi/cgi/cgi_main.c
  12. +1 −1 sapi/cli/php_cli.c
  13. +1 −1 sapi/milter/php_milter.c
View
3 NEWS
@@ -3,6 +3,9 @@ PHP NEWS
?? ??? 20??, PHP 5.3.0
- Removed the experimental RPL (master/slave) functions from mysqli. (Andrey)
+- Added 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. (Dmitry)
- Added new error mode E_DEPRECATED which is used to inform about stuff to be
dropped in future PHP versions. (Lars Strojny, Felipe, Marcus)
- Added and improved PHP syntax and semantics:
View
@@ -443,15 +443,15 @@ static void register_standard_class(TSRMLS_D) /* {{{ */
/* }}} */
#ifdef ZTS
-static zend_bool asp_tags_default = 0;
-static zend_bool short_tags_default = 1;
-static zend_bool ct_pass_ref_default = 1;
-static zend_bool extended_info_default = 0;
+static zend_bool asp_tags_default = 0;
+static zend_bool short_tags_default = 1;
+static zend_bool ct_pass_ref_default = 1;
+static zend_uint compiler_options_default = ZEND_COMPILE_DEFAULT;
#else
-# define asp_tags_default 0
-# define short_tags_default 1
-# define ct_pass_ref_default 1
-# define extended_info_default 0
+# define asp_tags_default 0
+# define short_tags_default 1
+# define ct_pass_ref_default 1
+# define compiler_options_default ZEND_COMPILE_DEFAULT
#endif
static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */
@@ -460,7 +460,7 @@ static void zend_set_default_compile_time_values(TSRMLS_D) /* {{{ */
CG(asp_tags) = asp_tags_default;
CG(short_tags) = short_tags_default;
CG(allow_call_time_pass_reference) = ct_pass_ref_default;
- CG(extended_info) = extended_info_default;
+ CG(compiler_options) = compiler_options_default;
}
/* }}} */
@@ -721,7 +721,7 @@ void zend_post_startup(TSRMLS_D) /* {{{ */
asp_tags_default = CG(asp_tags);
short_tags_default = CG(short_tags);
ct_pass_ref_default = CG(allow_call_time_pass_reference);
- extended_info_default = CG(extended_info);
+ compiler_options_default = CG(compiler_options);
zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC);
free(compiler_globals->function_table);
View
@@ -126,7 +126,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(dimension_llist), sizeof(int), NULL, 0);
zend_stack_init(&CG(list_stack));
- CG(handle_op_arrays) = 1;
CG(in_compilation) = 0;
CG(start_lineno) = 0;
CG(current_namespace) = NULL;
@@ -1241,7 +1240,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
zend_hash_update(CG(function_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &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);
opline->opcode = ZEND_EXT_NOP;
@@ -1420,7 +1419,9 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace
}
lcname = zend_str_tolower_dup(function_name->u.constant.value.str.val, function_name->u.constant.value.str.len);
- if (zend_hash_find(CG(function_table), lcname, function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) {
+ if ((zend_hash_find(CG(function_table), lcname, function_name->u.constant.value.str.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);
efree(lcname);
return 1; /* Dynamic */
@@ -1603,8 +1604,9 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_
efree(ns_lcname);
}
- if (zend_hash_find(CG(class_table), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&pce) == SUCCESS &&
- (*pce)->type == ZEND_INTERNAL_CLASS) {
+ if ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) ||
+ (zend_hash_find(CG(class_table), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&pce) == SUCCESS &&
+ (*pce)->type == ZEND_INTERNAL_CLASS)) {
/* There is an internal class with the same name exists.
PHP will need to perform additional cheks at run-time to
determine if we assume class in current namespace or
@@ -2727,7 +2729,6 @@ void zend_do_early_binding(TSRMLS_D)
{
zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
HashTable *table;
- zend_bool is_abstract_class = 0;
while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
opline--;
@@ -2741,57 +2742,44 @@ void zend_do_early_binding(TSRMLS_D)
table = CG(function_table);
break;
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:
- 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) {
- return;
- }
- } else if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS) {
- zval *parent_name = &(opline-1)->op2.u.constant;
- zend_class_entry **pce;
-
- if (zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) {
- return;
+ {
+ zend_op *fetch_class_opline = opline-1;
+ zval *parent_name = &fetch_class_opline->op2.u.constant;
+ zend_class_entry **pce;
+
+ if ((zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_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;
}
- 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;
}
- 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;
+ if (do_bind_inherited_class(opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
+ return;
}
- }
+ /* 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:
/* We currently don't early-bind classes that implement interfaces */
return;
@@ -2803,13 +2791,26 @@ void zend_do_early_binding(TSRMLS_D)
zend_hash_del(table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len);
zval_dtor(&opline->op1.u.constant);
zval_dtor(&opline->op2.u.constant);
- opline->opcode = ZEND_NOP;
- memset(&opline->op1, 0, sizeof(znode));
- memset(&opline->op2, 0, sizeof(znode));
- SET_UNUSED(opline->op1);
- SET_UNUSED(opline->op2);
+ MAKE_NOP(opline);
}
+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_lookup_class(Z_STRVAL(op_array->opcodes[opline_num-1].op2.u.constant), Z_STRLEN(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;
+ }
+}
void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC)
{
@@ -4462,7 +4463,7 @@ void zend_do_extended_info(TSRMLS_D)
{
zend_op *opline;
- if (!CG(extended_info)) {
+ if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return;
}
@@ -4478,7 +4479,7 @@ void zend_do_extended_fcall_begin(TSRMLS_D)
{
zend_op *opline;
- if (!CG(extended_info)) {
+ if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return;
}
@@ -4494,7 +4495,7 @@ void zend_do_extended_fcall_end(TSRMLS_D)
{
zend_op *opline;
- if (!CG(extended_info)) {
+ if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
return;
}
View
@@ -224,6 +224,7 @@ struct _zend_op_array {
zend_uint line_end;
char *doc_comment;
zend_uint doc_comment_len;
+ zend_uint early_binding; /* the linked list of delayed declarations */
void *reserved[ZEND_MAX_RESERVED_RESOURCES];
};
@@ -428,6 +429,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);
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);
@@ -711,6 +713,32 @@ END_EXTERN_C()
#define ZEND_TOSTRING_FUNC_NAME "__tostring"
#define ZEND_AUTOLOAD_FUNC_NAME "__autoload"
+/* 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 */
/*
View
@@ -1264,7 +1264,7 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSR
zval pv;
zend_op_array *new_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;
if (retval_ptr) {
@@ -1284,10 +1284,10 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSR
/*printf("Evaluating '%s'\n", pv.value.str.val);*/
- original_handle_op_arrays = CG(handle_op_arrays);
- CG(handle_op_arrays) = 0;
+ original_compiler_options = CG(compiler_options);
+ CG(compiler_options) = ZEND_COMPILE_DEFAULT_FOR_EVAL;
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) {
zval *local_retval_ptr=NULL;
View
@@ -55,6 +55,9 @@ END_EXTERN_C()
/* excpt.h on Digital Unix 4.0 defines function_table */
#undef function_table
+#define ZEND_EARLY_BINDING_COMPILE_TIME 0
+#define ZEND_EARLY_BINDING_DELAYED 1
+#define ZEND_EARLY_BINDING_DELAYED_ALL 2
typedef struct _zend_declarables {
zval ticks;
@@ -101,10 +104,6 @@ struct _zend_compiler_globals {
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 ini_parser_unbuffered_errors;
@@ -127,6 +126,8 @@ struct _zend_compiler_globals {
char *doc_comment;
zend_uint doc_comment_len;
+ zend_uint compiler_options; /* set of ZEND_COMPILE_* constants */
+
zval *current_namespace;
HashTable *current_import;
View
@@ -101,6 +101,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->early_binding = -1;
+
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);
@@ -364,10 +366,10 @@ int pass_two(zend_op_array *op_array TSRMLS_DC)
if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
return 0;
}
- if (CG(extended_info)) {
+ if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
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);
}
View
@@ -3962,6 +3962,19 @@ ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
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)
{
do_bind_function(EX(opline), EG(function_table), 0);
Oops, something went wrong.

0 comments on commit 8c885b8

Please sign in to comment.