Inline simple constant functions

diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c
index 75120d250120c999f8de613d37276d13b0f82195..79c1d90232a0bf2dee567846aa1b50ef8ff7e626 100644 (file)
--- a/ext/opcache/Optimizer/optimize_func_calls.c
+++ b/ext/opcache/Optimizer/optimize_func_calls.c
@@ -41,6 +41,91 @@ typedef struct _optimizer_call_info {
        zend_op       *opline;
 } optimizer_call_info;
 
+static void zend_delete_call_instructions(zend_op *opline)
+{
+       int call = 0;
+
+       while (1) {
+               switch (opline->opcode) {
+                       case ZEND_INIT_FCALL_BY_NAME:
+                       case ZEND_INIT_NS_FCALL_BY_NAME:
+                       case ZEND_INIT_STATIC_METHOD_CALL:
+                       case ZEND_INIT_METHOD_CALL:
+                       case ZEND_INIT_FCALL:
+                               if (call == 0) {
+                                       MAKE_NOP(opline);
+                                       return;
+                               }
+                               /* break missing intentionally */
+                       case ZEND_NEW:
+                       case ZEND_INIT_DYNAMIC_CALL:
+                       case ZEND_INIT_USER_CALL:
+                               call--;
+                               break;
+                       case ZEND_DO_FCALL:
+                       case ZEND_DO_ICALL:
+                       case ZEND_DO_UCALL:
+                       case ZEND_DO_FCALL_BY_NAME:
+                               call++;
+                               break;
+                       case ZEND_SEND_VAL:
+                       case ZEND_SEND_VAR:
+                       case ZEND_SEND_VAR_NO_REF:
+                       case ZEND_SEND_REF:
+                               if (call == 0) {
+                                       if (opline->op1_type & (IS_CONST|IS_CV)) {
+                                               MAKE_NOP(opline);
+                                       } else {
+                                               opline->opcode = ZEND_FREE;
+                                               opline->extended_value = 0;
+                                               opline->result.var = 0;
+                                       }
+                               }
+                               break;
+               }
+               opline--;
+       }
+}
+
+static void zend_try_inline_call(zend_op_array *op_array, zend_op *fcall, zend_op *opline, zend_function *func)
+{
+       if (func->type == ZEND_USER_FUNCTION
+        && !(func->op_array.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_HAS_TYPE_HINTS))
+        && fcall->extended_value >= func->op_array.required_num_args
+        && func->op_array.opcodes[func->op_array.num_args].opcode == ZEND_RETURN) {
+
+               zend_op *ret_opline = func->op_array.opcodes + func->op_array.num_args;
+
+               if (ret_opline->op1_type == IS_CONST) {
+
+                       if (fcall->extended_value < func->op_array.num_args) {
+                               /* don't inline funcions with named constants in default arguments */
+                               uint32_t n = fcall->extended_value;
+
+                               do {
+                                       if (Z_CONSTANT_P(RT_CONSTANT_EX(&func->op_array, func->op_array.opcodes[n].op2))) {
+                                               return;
+                                       }
+                                       n++;
+                               } while (n < func->op_array.num_args);
+                       }
+                       if (RETURN_VALUE_USED(opline)) {
+                               zval zv;
+
+                               ZVAL_DUP(&zv, RT_CONSTANT_EX(&func->op_array, ret_opline->op1));
+                               opline->opcode = ZEND_QM_ASSIGN;
+                               opline->op1_type = IS_CONST;
+                               opline->op1.constant = zend_optimizer_add_literal(op_array, &zv);
+                               SET_UNUSED(opline->op2);
+                       } else {
+                               MAKE_NOP(opline);
+                       }
+
+                       zend_delete_call_instructions(opline-1);
+               }
+       }
+}
+
 void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 {
        zend_op *opline = op_array->opcodes;
@@ -61,12 +146,12 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
                        case ZEND_INIT_NS_FCALL_BY_NAME:
                        case ZEND_INIT_STATIC_METHOD_CALL:
                        case ZEND_INIT_METHOD_CALL:
+                       case ZEND_INIT_FCALL:
                                call_stack[call].func = zend_optimizer_get_called_func(
                                        ctx->script, op_array, opline, 0);
                                /* break missing intentionally */
                        case ZEND_NEW:
                        case ZEND_INIT_DYNAMIC_CALL:
-                       case ZEND_INIT_FCALL:
                        case ZEND_INIT_USER_CALL:
                                call_stack[call].opline = opline;
                                call++;
@@ -79,7 +164,9 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
                                if (call_stack[call].func && call_stack[call].opline) {
                                        zend_op *fcall = call_stack[call].opline;
 
-                                       if (fcall->opcode == ZEND_INIT_FCALL_BY_NAME) {
+                                       if (fcall->opcode == ZEND_INIT_FCALL) {
+                                               /* nothing to do */
+                                       } else if (fcall->opcode == ZEND_INIT_FCALL_BY_NAME) {
                                                fcall->opcode = ZEND_INIT_FCALL;
                                                fcall->op1.num = zend_vm_calc_used_stack(fcall->extended_value, call_stack[call].func);
                                                Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]);
@@ -100,6 +187,10 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
                                        } else {
                                                ZEND_ASSERT(0);
                                        }
+
+                                       if (ZEND_OPTIMIZER_PASS_16 & ctx->optimization_level) {
+                                               zend_try_inline_call(op_array, fcall, opline, call_stack[call].func);
+                                       }
                                }
                                call_stack[call].func = NULL;
                                call_stack[call].opline = NULL;

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 66201751bcb2b45177263e82fd065d6a942951b7..c33b5459f55926def0d19038deddf63cbb175ac3 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -3186,7 +3186,6 @@ static void zend_update_type_info(const zend_op_array *op_array,
                                                }
                                        }
                                }
-                               ZEND_ASSERT(!ssa_vars[ssa_ops[i].result_def].phi_use_chain);
                                j = ssa_vars[ssa_ops[i].result_def].use_chain;
                                while (j >= 0) {
                                        switch (op_array->opcodes[j].opcode) {

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 35dff983625851daa584e4810bb974b4599500ff..43b355ee3c52ef9ddd994964ad6b278dfaa9aa9c 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -191,6 +191,18 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
                        opline->op1.constant = zend_optimizer_add_literal(op_array, val);
                        alloc_cache_slots_op1(op_array, opline, 2);
                        break;
+               case ZEND_SEND_VAR:
+                       opline->opcode = ZEND_SEND_VAL;
+                       opline->op1.constant = zend_optimizer_add_literal(op_array, val);
+                       break;
+               case ZEND_SEND_VAR_NO_REF_EX:
+                       opline->opcode = ZEND_SEND_VAL_EX;
+                       opline->op1.constant = zend_optimizer_add_literal(op_array, val);
+                       break;
+               case ZEND_SEPARATE:
+               case ZEND_SEND_VAR_NO_REF:
+                       zval_ptr_dtor(val);
+                       return 0;
                case ZEND_CONCAT:
                case ZEND_FAST_CONCAT:
                case ZEND_FETCH_R:
@@ -659,7 +671,7 @@ static void zend_optimize(zend_op_array      *op_array,
        if (ZEND_OPTIMIZER_PASS_3 & ctx->optimization_level) {
                zend_optimizer_pass3(op_array);
                if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_3) {
-                       zend_dump_op_array(op_array, 0, "after pass 1", NULL);
+                       zend_dump_op_array(op_array, 0, "after pass 3", NULL);
                }
        }
 
@@ -669,7 +681,7 @@ static void zend_optimize(zend_op_array      *op_array,
        if (ZEND_OPTIMIZER_PASS_4 & ctx->optimization_level) {
                zend_optimize_func_calls(op_array, ctx);
                if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_4) {
-                       zend_dump_op_array(op_array, 0, "after pass 1", NULL);
+                       zend_dump_op_array(op_array, 0, "after pass 4", NULL);
                }
        }
 

diff --git a/ext/opcache/Optimizer/zend_optimizer.h b/ext/opcache/Optimizer/zend_optimizer.h
index 1492d09b36735d1fa1daa65f2aca43c4f01a1375..41896b0afea96d5eaf9c6a492f5a99d6faaab2a8 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.h
+++ b/ext/opcache/Optimizer/zend_optimizer.h
@@ -40,6 +40,7 @@
 #define ZEND_OPTIMIZER_PASS_13         (1<<12)
 #define ZEND_OPTIMIZER_PASS_14         (1<<13)
 #define ZEND_OPTIMIZER_PASS_15         (1<<14)  /* Collect constants */
+#define ZEND_OPTIMIZER_PASS_16         (1<<15)  /* Inline functions */
 
 #define ZEND_OPTIMIZER_ALL_PASSES      0x7FFFFFFF
 

diff --git a/sapi/phpdbg/tests/finish_leave_001.phpt b/sapi/phpdbg/tests/finish_leave_001.phpt
index 774776c05f767196e10e20a1238d1b8c7fb39d25..e345752b004bd9673cf327889222260ab0aa2ae6 100644 (file)
--- a/sapi/phpdbg/tests/finish_leave_001.phpt
+++ b/sapi/phpdbg/tests/finish_leave_001.phpt
@@ -1,5 +1,7 @@
 --TEST--
 test finish and leave commands
+--INI--
+opcache.optimization_level=0
 --PHPDBG--
 b bar
 b 5