From 0c81b3eae26bf41fa49b4c3ca538494c2856e3b8 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Sat, 14 Jun 2014 21:59:44 +0200 Subject: [PATCH] Remove dead code --- Zend/zend_compile.c | 900 -------------------------------------------- Zend/zend_compile.h | 40 -- 2 files changed, 940 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 2e69763225..4972ecc15c 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -566,19 +566,6 @@ static inline zend_bool zend_is_function_or_method_call(const znode *variable) / } /* }}} */ -void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = op; - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - GET_NODE(result, opline->result); -} -/* }}} */ - void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ { zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); @@ -602,47 +589,6 @@ static void zend_do_op_data(zend_op *data_op, znode *value TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */ -{ - int last_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (last_op_number > 0) { - zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number-1]; - - switch (last_op->opcode) { - case ZEND_FETCH_OBJ_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_OBJ; - - zend_do_op_data(opline, op2 TSRMLS_CC); - SET_UNUSED(opline->result); - GET_NODE(result, last_op->result); - return; - case ZEND_FETCH_DIM_RW: - last_op->opcode = op; - last_op->extended_value = ZEND_ASSIGN_DIM; - - zend_do_op_data(opline, op2 TSRMLS_CC); - opline->op2.var = get_temporary_variable(CG(active_op_array)); - opline->op2_type = IS_VAR; - SET_UNUSED(opline->result); - GET_NODE(result,last_op->result); - return; - default: - break; - } - } - - opline->opcode = op; - SET_NODE(opline->op1, op1); - SET_NODE(opline->op2, op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC) /* {{{ */ { zend_op opline; @@ -701,110 +647,6 @@ void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC) /* { } /* }}} */ -void zend_do_fetch_static_member(znode *result, znode *class_name, znode *member_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - zend_llist *fetch_list_ptr; - zend_op opline; - - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - } - - zend_do_begin_variable_parse(TSRMLS_C); - fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - init_op(&opline TSRMLS_CC); - - opline.opcode = ZEND_FETCH_W; - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, member_name); - if (opline.op1_type == IS_CONST) { - GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant); - } - if (class_node.op_type == IS_CONST) { - opline.op2_type = IS_CONST; - opline.op2.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline.op2, &class_node); - } - GET_NODE(result,opline.result); - opline.extended_value |= ZEND_FETCH_STATIC_MEMBER; - - zend_llist_add_element(fetch_list_ptr, &opline); -} -/* }}} */ - -void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC) /* {{{ */ -{ - fetch_simple_variable(result, varname, 1 TSRMLS_CC); - - fetch_array_dim(result, result, first_dim TSRMLS_CC); -} -/* }}} */ - -void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - if (zend_is_function_or_method_call(parent)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, parent); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); - } - - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_DIM_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, parent); - SET_NODE(opline.op2, dim); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - ulong index; - int numeric = 0; - - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline.op2.constant)), Z_STRLEN(CONSTANT(opline.op2.constant))+1, index, numeric = 1); - if (numeric) { - zval_dtor(&CONSTANT(opline.op2.constant)); - ZVAL_LONG(&CONSTANT(opline.op2.constant), index); - } - } - - GET_NODE(result, opline.result); - - zend_llist_add_element(fetch_list_ptr, &opline); -} -/* }}} */ - -void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */ -{ - fetch_array_dim(result, parent, offset TSRMLS_CC); -} -/* }}} */ - -void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->result_type = IS_TMP_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - opline->opcode = ZEND_PRINT; - SET_NODE(opline->op1, arg); - SET_UNUSED(opline->op2); - GET_NODE(result, opline->result); -} -/* }}} */ - void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */ { zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); @@ -1929,135 +1771,6 @@ void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, } /* }}} */ -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */ -{ - zend_function *function; - zend_string *lcname; - char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant)); - - zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC); - - if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) { - /* We assume we call function from the current namespace - if it is not prefixed. */ - - /* In run-time PHP will check for function with full name and - internal function with short name */ - zend_do_begin_dynamic_function_call(function_name, 1 TSRMLS_CC); - return 1; - } - - lcname = STR_ALLOC(Z_STRLEN(function_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant)); - if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || - ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && - (function->type == ZEND_INTERNAL_FUNCTION))) { - zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC); - efree(lcname); - return 1; /* Dynamic */ - } - STR_RELEASE(Z_STR(function_name->u.constant)); - Z_STR(function_name->u.constant) = lcname; - - zend_push_function_call_entry(function TSRMLS_CC); - if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls + 1; - } - zend_do_extended_fcall_begin(TSRMLS_C); - return 0; -} -/* }}} */ - -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ -{ - zend_op *last_op; - int last_op_number; - - zend_do_end_variable_parse(left_bracket, BP_VAR_R, 0 TSRMLS_CC); - zend_do_begin_variable_parse(TSRMLS_C); - - last_op_number = get_next_op_number(CG(active_op_array))-1; - last_op = &CG(active_op_array)->opcodes[last_op_number]; - - if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1) - && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead"); - } - - /* Convert ZEND_FETCH_OBJ_R to ZEND_INIT_METHOD_CALL */ - last_op->opcode = ZEND_INIT_METHOD_CALL; - last_op->result_type = IS_UNUSED; - last_op->result.num = CG(context).nested_calls; - Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; - if (last_op->op2_type == IS_CONST) { - zval name; - name = CONSTANT(last_op->op2.constant); - if (Z_TYPE(name) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - Z_STR(name) = STR_COPY(Z_STR(name)); - FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - last_op->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC); - GET_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant); - } - - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; - } - zend_do_extended_fcall_begin(TSRMLS_C); -} -/* }}} */ - -void zend_do_clone(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_CLONE; - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - -void zend_do_begin_dynamic_function_call(znode *function_name, int ns_call TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (ns_call) { - /* In run-time PHP will check for function with full name and - internal function with short name */ - opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_ns_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - if (function_name->op_type == IS_CONST && Z_TYPE(function_name->u.constant) == IS_STRING) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &function_name->u.constant TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - } else { - SET_NODE(opline->op2, function_name); - } - } - - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; - } - zend_do_extended_fcall_begin(TSRMLS_C); -} -/* }}} */ - void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC) /* {{{ */ { znode tmp; @@ -2447,66 +2160,6 @@ void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_c } /* }}} */ -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC) /* {{{ */ -{ - znode class_node; - zend_op *opline; - - if (method_name->op_type == IS_CONST) { - char *lcname; - if (Z_TYPE(method_name->u.constant) != IS_STRING) { - zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); - } - lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant)); - if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) && - memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) { - zval_dtor(&method_name->u.constant); - method_name->op_type = IS_UNUSED; - } - efree(lcname); - } - - if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { - zend_resolve_class_name(class_name TSRMLS_CC); - class_node = *class_name; - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - } else { - zend_do_fetch_class(&class_node, class_name TSRMLS_CC); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->extended_value = class_node.EA ; - } - opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; - opline->result.num = CG(context).nested_calls; - if (class_node.op_type == IS_CONST) { - opline->op1_type = IS_CONST; - opline->op1.constant = - zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC); - } else { - SET_NODE(opline->op1, &class_node); - } - if (method_name->op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = - zend_add_func_name_literal(CG(active_op_array), &method_name->u.constant TSRMLS_CC); - if (opline->op1_type == IS_CONST) { - GET_CACHE_SLOT(opline->op2.constant); - } else { - GET_POLYMORPHIC_CACHE_SLOT(opline->op2.constant); - } - } else { - SET_NODE(opline->op2, method_name); - } - - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; - } - zend_do_extended_fcall_begin(TSRMLS_C); - return 1; /* Dynamic */ -} -/* }}} */ - void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC) /* {{{ */ { zend_op *opline; @@ -2556,156 +2209,6 @@ void zend_do_end_function_call(znode *function_name, znode *result, int is_metho static zend_bool zend_is_call(zend_ast *ast); -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - int original_op = op; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - zend_function *function_ptr = fcall->fbc; - int send_by_reference = 0; - int send_function = 0; - - fcall->arg_num++; - - if (fcall->uses_argument_unpacking) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use positional argument after argument unpacking"); - } - - if (original_op == ZEND_SEND_REF) { - if (function_ptr && - function_ptr->common.function_name && - function_ptr->common.type == ZEND_USER_FUNCTION && - !ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - zend_error_noreturn(E_COMPILE_ERROR, - "Call-time pass-by-reference has been removed; " - "If you would like to pass argument by reference, modify the declaration of %s().", - function_ptr->common.function_name->val); - } else { - zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed"); - } - return; - } - - if (function_ptr) { - if (ARG_MAY_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - // TODO.AST - if (op == ZEND_SEND_VAR /*&& param->op_type & (IS_VAR|IS_CV)*/) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - if (zend_is_call(param->u.ast)) { - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION | ZEND_ARG_SEND_SILENT; - } - } else { - op = ZEND_SEND_VAL; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(function_ptr, fcall->arg_num)) { - send_by_reference = ZEND_ARG_SEND_BY_REF; - } - } - - if (op == ZEND_SEND_VAR && zend_is_call(param->u.ast)) { - op = ZEND_SEND_VAR_NO_REF; - send_function = ZEND_ARG_SEND_FUNCTION; - } else if (op == ZEND_SEND_VAL && (param->op_type & (IS_VAR|IS_CV))) { - op = ZEND_SEND_VAR_NO_REF; - } - - if (op!=ZEND_SEND_VAR_NO_REF && send_by_reference==ZEND_ARG_SEND_BY_REF) { - /* change to passing by reference */ - /*switch (param->op_type) { - case IS_VAR: - case IS_CV: - op = ZEND_SEND_REF; - break; - default: - zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference"); - break; - }*/ - // TODO.AST - op = ZEND_SEND_REF; - } - - if (original_op == ZEND_SEND_VAR) { - switch (op) { - case ZEND_SEND_VAR_NO_REF: - AST_COMPILE_VAR(param, param->u.ast, BP_VAR_R); - break; - case ZEND_SEND_VAR: - if (function_ptr) { - AST_COMPILE_VAR(param, param->u.ast, BP_VAR_R); - } else { - // TODO.AST ! - //zend_do_end_variable_parse(param, BP_VAR_FUNC_ARG, fcall->arg_num TSRMLS_CC); - AST_COMPILE_VAR(param, param->u.ast, BP_VAR_R); - } - break; - case ZEND_SEND_REF: - AST_COMPILE_VAR(param, param->u.ast, BP_VAR_W); - break; - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (op == ZEND_SEND_VAR_NO_REF) { - if (function_ptr) { - opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND | send_by_reference | send_function; - } else { - opline->extended_value = send_function; - } - } else { - if (function_ptr) { - opline->extended_value = ZEND_DO_FCALL; - } else { - opline->extended_value = ZEND_DO_FCALL_BY_NAME; - } - } - opline->opcode = op; - SET_NODE(opline->op1, param); - opline->op2.opline_num = fcall->arg_num; - SET_UNUSED(opline->op2); - - if (++CG(context).used_stack > CG(active_op_array)->used_stack) { - CG(active_op_array)->used_stack = CG(context).used_stack; - } -} -/* }}} */ - -void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_function_call_entry *fcall = zend_stack_top(&CG(function_call_stack)); - - fcall->uses_argument_unpacking = 1; - - if (fcall->fbc) { - /* If argument unpacking is used argument numbers and sending modes can no longer be - * computed at compile time, thus we need access to EX(call). In order to have it we - * retroactively emit a ZEND_INIT_FCALL_BY_NAME opcode. */ - zval func_name; - ZVAL_STR(&func_name, STR_COPY(fcall->fbc->common.function_name)); - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_INIT_FCALL_BY_NAME; - opline->result.num = CG(context).nested_calls; - SET_UNUSED(opline->op1); - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal(CG(active_op_array), &func_name TSRMLS_CC); - GET_CACHE_SLOT(opline->op2.constant); - - ++CG(context).nested_calls; - fcall->fbc = NULL; - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_SEND_UNPACK; - SET_NODE(opline->op1, params); - SET_UNUSED(opline->op2); - opline->op2.num = fcall->arg_num; -} -/* }}} */ - static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */ { zend_op *opline; @@ -2805,52 +2308,6 @@ void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - zend_bool is_call = 0; - - if (!CG(active_op_array)->function_name) { - zend_error_noreturn(E_COMPILE_ERROR, "The \"yield\" expression can only be used inside a function"); - } - - CG(active_op_array)->fn_flags |= ZEND_ACC_GENERATOR; - - if (is_variable) { - is_call = zend_is_call(value->u.ast); - if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !is_call) { - AST_COMPILE_VAR(value, value->u.ast, BP_VAR_REF); - } else { - AST_COMPILE_VAR(value, value->u.ast, BP_VAR_R); - } - } - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_YIELD; - - if (value) { - SET_NODE(opline->op1, value); - - if (is_call) { - opline->extended_value = ZEND_RETURNS_FUNCTION; - } - } else { - SET_UNUSED(opline->op1); - } - - if (key) { - SET_NODE(opline->op2, key); - } else { - SET_UNUSED(opline->op2); - } - - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - GET_NODE(result, opline->result); -} -/* }}} */ - static int zend_add_try_element(zend_uint try_op TSRMLS_DC) /* {{{ */ { int try_catch_offset = CG(active_op_array)->last_try_catch++; @@ -5481,77 +4938,6 @@ void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* } /* }}} */ -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */ -{ - zend_op opline; - zend_llist *fetch_list_ptr = zend_stack_top(&CG(bp_stack)); - - if (object->op_type == IS_CV) { - if (object->u.op.var == CG(active_op_array)->this_var) { - object->op_type = IS_UNUSED; /* this means $this for objects */ - } - } else if (fetch_list_ptr->count == 1) { - zend_llist_element *le = fetch_list_ptr->head; - zend_op *opline_ptr = (zend_op *) le->data; - - if (opline_is_fetch_this(opline_ptr TSRMLS_CC)) { - zend_del_literal(CG(active_op_array), opline_ptr->op1.constant); - SET_UNUSED(opline_ptr->op1); /* this means $this for objects */ - SET_NODE(opline_ptr->op2, property); - /* if it was usual fetch, we change it to object fetch */ - switch (opline_ptr->opcode) { - case ZEND_FETCH_W: - opline_ptr->opcode = ZEND_FETCH_OBJ_W; - break; - case ZEND_FETCH_R: - opline_ptr->opcode = ZEND_FETCH_OBJ_R; - break; - case ZEND_FETCH_RW: - opline_ptr->opcode = ZEND_FETCH_OBJ_RW; - break; - case ZEND_FETCH_IS: - opline_ptr->opcode = ZEND_FETCH_OBJ_IS; - break; - case ZEND_FETCH_UNSET: - opline_ptr->opcode = ZEND_FETCH_OBJ_UNSET; - break; - case ZEND_FETCH_FUNC_ARG: - opline_ptr->opcode = ZEND_FETCH_OBJ_FUNC_ARG; - break; - } - if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) { - GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant); - } - GET_NODE(result, opline_ptr->result); - return; - } - } - - if (zend_is_function_or_method_call(object)) { - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_SEPARATE; - SET_NODE(opline.op1, object); - SET_UNUSED(opline.op2); - opline.result_type = IS_VAR; - opline.result.var = opline.op1.var; - zend_llist_add_element(fetch_list_ptr, &opline); - } - - init_op(&opline TSRMLS_CC); - opline.opcode = ZEND_FETCH_OBJ_W; /* the backpatching routine assumes W */ - opline.result_type = IS_VAR; - opline.result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline.op1, object); - SET_NODE(opline.op2, property); - if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant); - } - GET_NODE(result, opline.result); - - zend_llist_add_element(fetch_list_ptr, &opline); -} -/* }}} */ - void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ { zend_string *name; @@ -5573,38 +4959,6 @@ void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ } /* }}} */ -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline; - - new_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_NEW; - opline->extended_value = CG(context).nested_calls; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, class_type); - SET_UNUSED(opline->op2); - - zend_push_function_call_entry(NULL TSRMLS_CC); - if (++CG(context).nested_calls > CG(active_op_array)->nested_calls) { - CG(active_op_array)->nested_calls = CG(context).nested_calls; - } -} -/* }}} */ - -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /* {{{ */ -{ - znode ctor_result; - - zend_do_end_function_call(NULL, &ctor_result, 1, 0 TSRMLS_CC); - zend_do_free(&ctor_result TSRMLS_CC); - - CG(active_op_array)->opcodes[new_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - GET_NODE(result, CG(active_op_array)->opcodes[new_token->u.op.opline_num].result); -} -/* }}} */ - static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */ { zend_constant *c = NULL; @@ -6009,108 +5363,6 @@ str_index: } /* }}} */ -void zend_do_add_list_element(const znode *element TSRMLS_DC) /* {{{ */ -{ - list_llist_element lle; - - if (element) { - zend_check_writable_variable(element); - - lle.var = *element; - zend_llist_copy(&lle.dimensions, &CG(dimension_llist)); - zend_llist_prepend_element(&CG(list_llist), &lle); - } - (*((int *)CG(dimension_llist).tail->data))++; -} -/* }}} */ - -void zend_do_new_list_begin(TSRMLS_D) /* {{{ */ -{ - int current_dimension = 0; - zend_llist_add_element(&CG(dimension_llist), ¤t_dimension); -} -/* }}} */ - -void zend_do_new_list_end(TSRMLS_D) /* {{{ */ -{ - zend_llist_remove_tail(&CG(dimension_llist)); - (*((int *)CG(dimension_llist).tail->data))++; -} -/* }}} */ - -void zend_do_list_init(TSRMLS_D) /* {{{ */ -{ - zend_stack_push(&CG(list_stack), &CG(list_llist)); - zend_stack_push(&CG(list_stack), &CG(dimension_llist)); - zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0); - zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0); - zend_do_new_list_begin(TSRMLS_C); -} -/* }}} */ - -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */ -{ - zend_llist_element *le; - zend_llist_element *dimension; - zend_op *opline; - znode last_container; - - le = CG(list_llist).head; - while (le) { - zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions; - dimension = tmp_dimension_llist->head; - while (dimension) { - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - if (dimension == tmp_dimension_llist->head) { /* first */ - last_container = *expr; - switch (expr->op_type) { - case IS_VAR: - case IS_CV: - opline->opcode = ZEND_FETCH_DIM_R; - break; - case IS_TMP_VAR: - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - case IS_CONST: /* fetch_dim_tmp_var will handle this bogus fetch */ - zval_copy_ctor(&expr->u.constant); - opline->opcode = ZEND_FETCH_DIM_TMP_VAR; - break; - } - opline->extended_value |= ZEND_FETCH_ADD_LOCK; - } else { - opline->opcode = ZEND_FETCH_DIM_R; - } - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, &last_container); - opline->op2_type = IS_CONST; - LITERAL_LONG(opline->op2, *((int *) dimension->data)); - GET_NODE(&last_container, opline->result); - dimension = dimension->next; - } - ((list_llist_element *) le->data)->value = last_container; - zend_llist_destroy(&((list_llist_element *) le->data)->dimensions); - zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC); - zend_do_free(result TSRMLS_CC); - le = le->next; - } - zend_llist_destroy(&CG(dimension_llist)); - zend_llist_destroy(&CG(list_llist)); - *result = *expr; - { - zend_llist *p; - - /* restore previous lists */ - p = zend_stack_top(&CG(list_stack)); - CG(dimension_llist) = *p; - zend_stack_del_top(&CG(list_stack)); - p = zend_stack_top(&CG(list_stack)); - CG(list_llist) = *p; - zend_stack_del_top(&CG(list_stack)); - } -} -/* }}} */ - void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */ { void** list = emalloc(sizeof(void*) * 2); @@ -6245,20 +5497,6 @@ void zend_do_fetch_global_variable(znode *varname, const znode *static_assignmen } /* }}} */ -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_CAST; - opline->result_type = IS_VAR; - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, expr); - SET_UNUSED(opline->op2); - opline->extended_value = type; - GET_NODE(result, opline->result); -} -/* }}} */ - void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */ { zend_do_extended_fcall_begin(TSRMLS_C); @@ -6659,19 +5897,6 @@ void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_EXIT; - SET_NODE(opline->op1, message); - SET_UNUSED(opline->op2); - - result->op_type = IS_CONST; - ZVAL_BOOL(&result->u.constant, 1); -} -/* }}} */ - void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ { zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); @@ -6695,131 +5920,6 @@ void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */ } /* }}} */ -void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - int op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - if (value->op_type == IS_VAR || value->op_type == IS_CV) { - opline->opcode = ZEND_JMP_SET_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_JMP_SET; - opline->result_type = IS_TMP_VAR; - } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, value); - SET_UNUSED(opline->op2); - - GET_NODE(colon_token, opline->result); - - jmp_token->u.op.opline_num = op_number; - - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - SET_NODE(opline->result, colon_token); - if (colon_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].opcode = ZEND_JMP_SET_VAR; - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - } - } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; - } - opline->extended_value = 0; - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - - GET_NODE(result, opline->result); - - CG(active_op_array)->opcodes[jmp_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array)); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */ -{ - int jmpz_op_number = get_next_op_number(CG(active_op_array)); - zend_op *opline; - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - opline->opcode = ZEND_JMPZ; - SET_NODE(opline->op1, cond); - SET_UNUSED(opline->op2); - opline->op2.opline_num = jmpz_op_number; - GET_NODE(qm_token, opline->op2); - - INC_BPC(CG(active_op_array)); -} -/* }}} */ - -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - CG(active_op_array)->opcodes[qm_token->u.op.opline_num].op2.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */ - - if (true_value->op_type == IS_VAR || true_value->op_type == IS_CV) { - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - opline->result_type = IS_TMP_VAR; - } - opline->result.var = get_temporary_variable(CG(active_op_array)); - SET_NODE(opline->op1, true_value); - SET_UNUSED(opline->op2); - - GET_NODE(qm_token, opline->result); - colon_token->u.op.opline_num = get_next_op_number(CG(active_op_array)); - - opline = get_next_op(CG(active_op_array) TSRMLS_CC); - opline->opcode = ZEND_JMP; - SET_UNUSED(opline->op1); - SET_UNUSED(opline->op2); -} -/* }}} */ - -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */ -{ - zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); - - SET_NODE(opline->result, qm_token); - if (qm_token->op_type == IS_TMP_VAR) { - if (false_value->op_type == IS_VAR || false_value->op_type == IS_CV) { - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].opcode = ZEND_QM_ASSIGN_VAR; - CG(active_op_array)->opcodes[colon_token->u.op.opline_num - 1].result_type = IS_VAR; - opline->opcode = ZEND_QM_ASSIGN_VAR; - opline->result_type = IS_VAR; - } else { - opline->opcode = ZEND_QM_ASSIGN; - } - } else { - opline->opcode = ZEND_QM_ASSIGN_VAR; - } - SET_NODE(opline->op1, false_value); - SET_UNUSED(opline->op2); - - CG(active_op_array)->opcodes[colon_token->u.op.opline_num].op1.opline_num = get_next_op_number(CG(active_op_array)); - - GET_NODE(result, opline->result); - - DEC_BPC(CG(active_op_array)); -} -/* }}} */ - void zend_do_extended_info(TSRMLS_D) /* {{{ */ { zend_op *opline; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index f814288ccd..bbf2bc7274 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -467,9 +467,7 @@ int zend_get_zendleng(TSRMLS_D); /* parser-driven code generators */ -void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC); void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC); -void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC); void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC); void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC); void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC); @@ -478,11 +476,6 @@ void zend_do_indirect_reference(znode *result, znode *variable TSRMLS_DC); void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC); void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type 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_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC); -void zend_do_fetch_static_member(znode *result, znode *class_name, znode *member_name TSRMLS_DC); -void zend_do_print(znode *result, znode *arg TSRMLS_DC); void zend_do_echo(znode *arg TSRMLS_DC); typedef int (*unary_op_type)(zval *, zval * TSRMLS_DC); typedef int (*binary_op_type)(zval *, zval *, zval * TSRMLS_DC); @@ -521,16 +514,10 @@ int zend_do_verify_access_types(const znode *current_access_type, const znode *n void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC); void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC); void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC); -int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC); -void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC); -void zend_do_clone(znode *result, znode *expr TSRMLS_DC); -void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC); void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC); void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC); -int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC); void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC); void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC); -void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC); void zend_do_handle_exception(TSRMLS_D); void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC); @@ -564,9 +551,6 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent void zend_do_early_binding(TSRMLS_D); ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC); -void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC); -void zend_do_unpack_params(znode *params TSRMLS_DC); - void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC); void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC); @@ -586,17 +570,8 @@ void zend_do_end_class_declaration(const znode *class_token, const znode *parent void zend_do_declare_property(znode *var_name, znode *value, zend_uint access_type TSRMLS_DC); void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC); -void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC); - void zend_do_halt_compiler_register(TSRMLS_D); -void zend_do_push_object(const znode *object TSRMLS_DC); -void zend_do_pop_object(znode *object TSRMLS_DC); - - -void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC); -void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC); - void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC); void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC); @@ -604,18 +579,12 @@ void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC); void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC); void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC); void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC); -void zend_do_list_init(TSRMLS_D); -void zend_do_list_end(znode *result, znode *expr TSRMLS_DC); -void zend_do_add_list_element(const znode *element TSRMLS_DC); -void zend_do_new_list_begin(TSRMLS_D); -void zend_do_new_list_end(TSRMLS_D); /* Functions for a null terminated pointer list, used for traits parsing and compilation */ void zend_init_list(void *result, void *item TSRMLS_DC); void zend_add_to_list(void *result, void *item TSRMLS_DC); -void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC); void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC); void zend_do_unset(znode *variable TSRMLS_DC); @@ -631,18 +600,9 @@ void zend_do_declare_begin(TSRMLS_D); void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC); void zend_do_declare_end(const znode *declare_token TSRMLS_DC); -void zend_do_exit(znode *result, znode *message TSRMLS_DC); - void zend_do_begin_silence(znode *strudel_token TSRMLS_DC); void zend_do_end_silence(znode *strudel_token TSRMLS_DC); -void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC); -void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC); - -void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC); -void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC); -void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC); - void zend_do_extended_info(TSRMLS_D); void zend_do_extended_fcall_begin(TSRMLS_D); void zend_do_extended_fcall_end(TSRMLS_D); -- 2.50.1