/src/php-src/Zend/Optimizer/pass1.c

Source
/*
   +----------------------------------------------------------------------+
   | Zend OPcache                                                         |
   +----------------------------------------------------------------------+
   | Copyright © The PHP Group and Contributors.                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | Authors: Andi Gutmans <andi@php.net>                                 |
   |          Zeev Suraski <zeev@php.net>                                 |
   |          Stanislav Malyshev <stas@zend.com>                          |
   |          Dmitry Stogov <dmitry@php.net>                              |
   +----------------------------------------------------------------------+
*/

/* pass 1 (Simple local optimizations)
 * - persistent constant substitution (true, false, null, etc)
 * - constant casting (ADD expects numbers, CONCAT strings, etc)
 * - constant expression evaluation
 * - optimize constant conditional JMPs
 * - pre-evaluate constant function calls
 */

#include "Optimizer/zend_optimizer.h"
#include "Optimizer/zend_optimizer_internal.h"
#include "zend_API.h"
#include "zend_constants.h"
#include "zend_execute.h"
#include "zend_vm.h"

#define TO_STRING_NOWARN(val) do { \
  if (Z_TYPE_P(val) < IS_ARRAY) { \
    convert_to_string(val); \
  } \
} while (0)

static void replace_by_const_or_qm_assign(zend_op_array *op_array, zend_op *opline, zval *result) {
  if (opline->op1_type == IS_CONST) {
    literal_dtor(&ZEND_OP1_LITERAL(opline));
  }
  if (opline->op2_type == IS_CONST) {
    literal_dtor(&ZEND_OP2_LITERAL(opline));
  }
  if (zend_optimizer_replace_by_const(op_array, opline + 1, opline->result_type, opline->result.var, result)) {
    MAKE_NOP(opline);
  } else {
    opline->opcode = ZEND_QM_ASSIGN;
    opline->extended_value = 0;
    SET_UNUSED(opline->op2);
    zend_optimizer_update_op1_const(op_array, opline, result);
  }
}

void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
{
  zend_op *opline = op_array->opcodes;
  zend_op *end = opline + op_array->last;
  bool collect_constants = (ZEND_OPTIMIZER_PASS_15 & ctx->optimization_level)?
    (op_array == &ctx->script->main_op_array) : 0;
  zval result;

  while (opline < end) {
    switch (opline->opcode) {
    case ZEND_CONCAT:
    case ZEND_FAST_CONCAT:
      if (opline->op1_type == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
        TO_STRING_NOWARN(&ZEND_OP1_LITERAL(opline));
      }
      if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
        TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
      }
      ZEND_FALLTHROUGH;
    case ZEND_ADD:
    case ZEND_SUB:
    case ZEND_MUL:
    case ZEND_DIV:
    case ZEND_POW:
    case ZEND_MOD:
    case ZEND_SL:
    case ZEND_SR:
    case ZEND_BW_OR:
    case ZEND_BW_AND:
    case ZEND_BW_XOR:
    case ZEND_IS_EQUAL:
    case ZEND_IS_NOT_EQUAL:
    case ZEND_IS_SMALLER:
    case ZEND_IS_SMALLER_OR_EQUAL:
    case ZEND_IS_IDENTICAL:
    case ZEND_IS_NOT_IDENTICAL:
    case ZEND_BOOL_XOR:
    case ZEND_SPACESHIP:
    case ZEND_CASE:
    case ZEND_CASE_STRICT:
      if (opline->op1_type == IS_CONST && opline->op2_type == IS_CONST &&
          zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
        replace_by_const_or_qm_assign(op_array, opline, &result);
      }
      break;

    case ZEND_ASSIGN_OP:
      if (opline->extended_value == ZEND_CONCAT && opline->op2_type == IS_CONST
          && Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
        TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
      }
      break;

    case ZEND_CAST:
      if (opline->op1_type == IS_CONST &&
          zend_optimizer_eval_cast(&result, opline->extended_value, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
        replace_by_const_or_qm_assign(op_array, opline, &result);
      }
      break;

    case ZEND_BW_NOT:
    case ZEND_BOOL_NOT:
      if (opline->op1_type == IS_CONST &&
          zend_optimizer_eval_unary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
        replace_by_const_or_qm_assign(op_array, opline, &result);
      }
      break;

    case ZEND_FETCH_CONSTANT:
      if (opline->op2_type == IS_CONST &&
        Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
        zend_string_equals_literal(Z_STR(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__")) {
        /* substitute __COMPILER_HALT_OFFSET__ constant */
        zend_execute_data *orig_execute_data = EG(current_execute_data);
        zend_execute_data fake_execute_data;
        zval *offset;

        memset(&fake_execute_data, 0, sizeof(zend_execute_data));
        fake_execute_data.func = (zend_function*)op_array;
        EG(current_execute_data) = &fake_execute_data;
        if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1)) != NULL) {

          literal_dtor(&ZEND_OP2_LITERAL(opline));
          replace_by_const_or_qm_assign(op_array, opline, offset);
        }
        EG(current_execute_data) = orig_execute_data;
        break;
      }

      if (opline->op2_type == IS_CONST &&
        Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
        /* substitute persistent constants */
        if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &result, true)) {
          if (!ctx->constants || !zend_optimizer_get_collected_constant(ctx->constants, &ZEND_OP2_LITERAL(opline), &result)) {
            break;
          }
        }
        if (Z_TYPE(result) == IS_CONSTANT_AST) {
          break;
        }
        replace_by_const_or_qm_assign(op_array, opline, &result);
      }
      break;

    case ZEND_FETCH_CLASS_CONSTANT: {
      bool is_prototype;
      const zend_class_constant *cc = zend_fetch_class_const_info(ctx->script, op_array, opline, &is_prototype);
      if (!cc || is_prototype) {
        break;
      }
      const zval *c = &cc->value;
      if (Z_TYPE_P(c) == IS_CONSTANT_AST) {
        zend_ast *ast = Z_ASTVAL_P(c);
        if (ast->kind != ZEND_AST_CONSTANT
         || !zend_optimizer_get_persistent_constant(zend_ast_get_constant_name(ast), &result, true)
         || Z_TYPE(result) == IS_CONSTANT_AST) {
          break;
        }
      } else {
        ZVAL_COPY_OR_DUP(&result, c);
      }
      replace_by_const_or_qm_assign(op_array, opline, &result);
      break;
    }

    case ZEND_DO_ICALL: {
      zend_op *send1_opline = opline - 1;
      zend_op *send2_opline = NULL;
      zend_op *init_opline = NULL;

      while (send1_opline->opcode == ZEND_NOP) {
        send1_opline--;
      }
      if (send1_opline->opcode != ZEND_SEND_VAL ||
          send1_opline->op1_type != IS_CONST) {
        /* don't collect constants after unknown function call */
        collect_constants = false;
        break;
      }
      if (send1_opline->op2.num == 2) {
        send2_opline = send1_opline;
        send1_opline--;
        while (send1_opline->opcode == ZEND_NOP) {
          send1_opline--;
        }
        if (send1_opline->opcode != ZEND_SEND_VAL ||
            send1_opline->op1_type != IS_CONST) {
          /* don't collect constants after unknown function call */
          collect_constants = false;
          break;
        }
      }
      init_opline = send1_opline - 1;
      while (init_opline->opcode == ZEND_NOP) {
        init_opline--;
      }
      if (init_opline->opcode != ZEND_INIT_FCALL ||
          init_opline->op2_type != IS_CONST ||
          Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) {
        /* don't collect constants after unknown function call */
        collect_constants = false;
        break;
      }

      /* define("name", scalar); */
      if (zend_string_equals_literal_ci(Z_STR(ZEND_OP2_LITERAL(init_opline)), "define")) {

        if (Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING && send2_opline) {

          if (collect_constants) {
            zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(send1_opline), &ZEND_OP1_LITERAL(send2_opline));
          }

          if (RESULT_UNUSED(opline) &&
              !zend_memnstr(Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)), "::", sizeof("::") - 1, Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)) + Z_STRLEN(ZEND_OP1_LITERAL(send1_opline)))) {

            opline->opcode = ZEND_DECLARE_CONST;
            opline->op1_type = IS_CONST;
            opline->op2_type = IS_CONST;
            opline->result_type = IS_UNUSED;
            opline->op1.constant = send1_opline->op1.constant;
            opline->op2.constant = send2_opline->op1.constant;
            opline->result.num = 0;

            literal_dtor(&ZEND_OP2_LITERAL(init_opline));
            MAKE_NOP(init_opline);
            MAKE_NOP(send1_opline);
            MAKE_NOP(send2_opline);
          }
          break;
        }
      }

      if (!send2_opline && Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING &&
          zend_optimizer_eval_special_func_call(&result, Z_STR(ZEND_OP2_LITERAL(init_opline)), Z_STR(ZEND_OP1_LITERAL(send1_opline))) == SUCCESS) {
        literal_dtor(&ZEND_OP2_LITERAL(init_opline));
        MAKE_NOP(init_opline);
        literal_dtor(&ZEND_OP1_LITERAL(send1_opline));
        MAKE_NOP(send1_opline);
        replace_by_const_or_qm_assign(op_array, opline, &result);
        break;
      }

      /* don't collect constants after any other function call */
      collect_constants = false;
      break;
    }
    case ZEND_DO_UCALL:
    case ZEND_DO_FCALL:
    case ZEND_DO_FCALL_BY_NAME:
    case ZEND_FRAMELESS_ICALL_0:
    case ZEND_FRAMELESS_ICALL_1:
    case ZEND_FRAMELESS_ICALL_2:
    case ZEND_FRAMELESS_ICALL_3:
      /* don't collect constants after any UCALL/FCALL/FRAMELESS ICALL */
      collect_constants = 0;
      break;
    case ZEND_STRLEN:
      if (opline->op1_type == IS_CONST &&
          zend_optimizer_eval_strlen(&result, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
        replace_by_const_or_qm_assign(op_array, opline, &result);
      }
      break;
    case ZEND_DEFINED:
      if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &result, false)) {
        break;
      }
      ZVAL_TRUE(&result);
      literal_dtor(&ZEND_OP1_LITERAL(opline));
      replace_by_const_or_qm_assign(op_array, opline, &result);
      break;
    case ZEND_DECLARE_CONST:
      if (collect_constants &&
          Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
          Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_CONSTANT_AST) {
        zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline));
      }
      break;

    case ZEND_JMPZ_EX:
    case ZEND_JMPNZ_EX:
      /* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
         in case we know it wouldn't jump */
      if (opline->op1_type == IS_CONST) {
        if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
          if (opline->opcode == ZEND_JMPZ_EX) {
            opline->opcode = ZEND_QM_ASSIGN;
            zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
            ZVAL_TRUE(&ZEND_OP1_LITERAL(opline));
            opline->op2.num = 0;
            break;
          }
        } else {
          if (opline->opcode == ZEND_JMPNZ_EX) {
            opline->opcode = ZEND_QM_ASSIGN;
            zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
            ZVAL_FALSE(&ZEND_OP1_LITERAL(opline));
            opline->op2.num = 0;
            break;
          }
        }
      }
      collect_constants = false;
      break;

    case ZEND_JMPZ:
    case ZEND_JMPNZ:
      if (opline->op1_type == IS_CONST) {
        bool should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));

        if (opline->opcode == ZEND_JMPZ) {
          should_jmp = !should_jmp;
        }
        literal_dtor(&ZEND_OP1_LITERAL(opline));
        opline->op1_type = IS_UNUSED;
        if (should_jmp) {
          opline->opcode = ZEND_JMP;
          COPY_NODE(opline->op1, opline->op2);
          opline->op2.num = 0;
        } else {
          MAKE_NOP(opline);
          break;
        }
      }
      collect_constants = false;
      break;

    case ZEND_RETURN:
    case ZEND_RETURN_BY_REF:
    case ZEND_GENERATOR_RETURN:
    case ZEND_THROW:
    case ZEND_MATCH_ERROR:
    case ZEND_CATCH:
    case ZEND_FAST_CALL:
    case ZEND_FAST_RET:
    case ZEND_JMP:
    case ZEND_FE_RESET_R:
    case ZEND_FE_RESET_RW:
    case ZEND_FE_FETCH_R:
    case ZEND_FE_FETCH_RW:
    case ZEND_JMP_SET:
    case ZEND_COALESCE:
    case ZEND_ASSERT_CHECK:
    case ZEND_JMP_NULL:
    case ZEND_VERIFY_NEVER_TYPE:
    case ZEND_BIND_INIT_STATIC_OR_JMP:
    case ZEND_JMP_FRAMELESS:
      collect_constants = false;
      break;
    }
    opline++;
  }
}

Coverage Report

Created: 2026-06-13 07:01

Line	Count	Source
1		/*
2		+----------------------------------------------------------------------+
3		\| Zend OPcache \|
4		+----------------------------------------------------------------------+
5		\| Copyright © The PHP Group and Contributors. \|
6		+----------------------------------------------------------------------+
7		\| This source file is subject to the Modified BSD License that is \|
8		\| bundled with this package in the file LICENSE, and is available \|
9		\| through the World Wide Web at <https://www.php.net/license/>. \|
10		\| \|
11		\| SPDX-License-Identifier: BSD-3-Clause \|
12		+----------------------------------------------------------------------+
13		\| Authors: Andi Gutmans <andi@php.net> \|
14		\| Zeev Suraski <zeev@php.net> \|
15		\| Stanislav Malyshev <stas@zend.com> \|
16		\| Dmitry Stogov <dmitry@php.net> \|
17		+----------------------------------------------------------------------+
18		*/
19
20		/* pass 1 (Simple local optimizations)
21		* - persistent constant substitution (true, false, null, etc)
22		* - constant casting (ADD expects numbers, CONCAT strings, etc)
23		* - constant expression evaluation
24		* - optimize constant conditional JMPs
25		* - pre-evaluate constant function calls
26		*/
27
28		#include "Optimizer/zend_optimizer.h"
29		#include "Optimizer/zend_optimizer_internal.h"
30		#include "zend_API.h"
31		#include "zend_constants.h"
32		#include "zend_execute.h"
33		#include "zend_vm.h"
34
35	71	#define TO_STRING_NOWARN(val) do { \
36	71	if (Z_TYPE_P(val) < IS_ARRAY) { \
37	59	convert_to_string(val); \
38	59	} \
39	71	} while (0)
40
41	1.87k	static void replace_by_const_or_qm_assign(zend_op_array op_array, zend_op opline, zval *result) {
42	1.87k	if (opline->op1_type == IS_CONST) {
43	1.84k	literal_dtor(&ZEND_OP1_LITERAL(opline));
44	1.84k	}
45	1.87k	if (opline->op2_type == IS_CONST) {
46	1.41k	literal_dtor(&ZEND_OP2_LITERAL(opline));
47	1.41k	}
48	1.87k	if (zend_optimizer_replace_by_const(op_array, opline + 1, opline->result_type, opline->result.var, result)) {
49	1.82k	MAKE_NOP(opline);
50	1.82k	} else {
51	48	opline->opcode = ZEND_QM_ASSIGN;
52	48	opline->extended_value = 0;
53	48	SET_UNUSED(opline->op2);
54	48	zend_optimizer_update_op1_const(op_array, opline, result);
55	48	}
56	1.87k	}
57
58		void zend_optimizer_pass1(zend_op_array op_array, zend_optimizer_ctx ctx)
59	94.6k	{
60	94.6k	zend_op *opline = op_array->opcodes;
61	94.6k	zend_op *end = opline + op_array->last;
62	94.6k	bool collect_constants = (ZEND_OPTIMIZER_PASS_15 & ctx->optimization_level)?
63	94.6k	(op_array == &ctx->script->main_op_array) : 0;
64	94.6k	zval result;
65
66	2.46M	while (opline < end) {
67	2.36M	switch (opline->opcode) {
68	47.2k	case ZEND_CONCAT:
69	53.6k	case ZEND_FAST_CONCAT:
70	53.6k	if (opline->op1_type == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
71	0	TO_STRING_NOWARN(&ZEND_OP1_LITERAL(opline));
72	0	}
73	53.6k	if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
74	0	TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
75	0	}
76	53.6k	ZEND_FALLTHROUGH;
77	63.0k	case ZEND_ADD:
78	70.3k	case ZEND_SUB:
79	78.7k	case ZEND_MUL:
80	83.3k	case ZEND_DIV:
81	83.8k	case ZEND_POW:
82	87.2k	case ZEND_MOD:
83	89.1k	case ZEND_SL:
84	90.3k	case ZEND_SR:
85	91.8k	case ZEND_BW_OR:
86	99.7k	case ZEND_BW_AND:
87	105k	case ZEND_BW_XOR:
88	119k	case ZEND_IS_EQUAL:
89	123k	case ZEND_IS_NOT_EQUAL:
90	133k	case ZEND_IS_SMALLER:
91	137k	case ZEND_IS_SMALLER_OR_EQUAL:
92	139k	case ZEND_IS_IDENTICAL:
93	140k	case ZEND_IS_NOT_IDENTICAL:
94	141k	case ZEND_BOOL_XOR:
95	141k	case ZEND_SPACESHIP:
96	142k	case ZEND_CASE:
97	142k	case ZEND_CASE_STRICT:
98	142k	if (opline->op1_type == IS_CONST && opline->op2_type == IS_CONST &&
99	8.10k	zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
100	332	replace_by_const_or_qm_assign(op_array, opline, &result);
101	332	}
102	142k	break;
103
104	86.5k	case ZEND_ASSIGN_OP:
105	86.5k	if (opline->extended_value == ZEND_CONCAT && opline->op2_type == IS_CONST
106	295	&& Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
107	71	TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
108	71	}
109	86.5k	break;
110
111	3.50k	case ZEND_CAST:
112	3.50k	if (opline->op1_type == IS_CONST &&
113	868	zend_optimizer_eval_cast(&result, opline->extended_value, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
114	448	replace_by_const_or_qm_assign(op_array, opline, &result);
115	448	}
116	3.50k	break;
117
118	20.3k	case ZEND_BW_NOT:
119	31.2k	case ZEND_BOOL_NOT:
120	31.2k	if (opline->op1_type == IS_CONST &&
121	154	zend_optimizer_eval_unary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
122	4	replace_by_const_or_qm_assign(op_array, opline, &result);
123	4	}
124	31.2k	break;
125
126	23.4k	case ZEND_FETCH_CONSTANT:
127	23.4k	if (opline->op2_type == IS_CONST &&
128	23.4k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
129	23.4k	zend_string_equals_literal(Z_STR(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__")) {
130		/* substitute __COMPILER_HALT_OFFSET__ constant */
131	8	zend_execute_data *orig_execute_data = EG(current_execute_data);
132	8	zend_execute_data fake_execute_data;
133	8	zval *offset;
134
135	8	memset(&fake_execute_data, 0, sizeof(zend_execute_data));
136	8	fake_execute_data.func = (zend_function*)op_array;
137	8	EG(current_execute_data) = &fake_execute_data;
138	8	if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1)) != NULL) {
139
140	0	literal_dtor(&ZEND_OP2_LITERAL(opline));
141	0	replace_by_const_or_qm_assign(op_array, opline, offset);
142	0	}
143	8	EG(current_execute_data) = orig_execute_data;
144	8	break;
145	8	}
146
147	23.4k	if (opline->op2_type == IS_CONST &&
148	23.4k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
149		/* substitute persistent constants */
150	23.4k	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &result, true)) {
151	23.4k	if (!ctx->constants \|\| !zend_optimizer_get_collected_constant(ctx->constants, &ZEND_OP2_LITERAL(opline), &result)) {
152	23.4k	break;
153	23.4k	}
154	23.4k	}
155	0	if (Z_TYPE(result) == IS_CONSTANT_AST) {
156	0	break;
157	0	}
158	0	replace_by_const_or_qm_assign(op_array, opline, &result);
159	0	}
160	0	break;
161
162	4.01k	case ZEND_FETCH_CLASS_CONSTANT: {
163	4.01k	bool is_prototype;
164	4.01k	const zend_class_constant *cc = zend_fetch_class_const_info(ctx->script, op_array, opline, &is_prototype);
165	4.01k	if (!cc \|\| is_prototype) {
166	2.36k	break;
167	2.36k	}
168	1.64k	const zval *c = &cc->value;
169	1.64k	if (Z_TYPE_P(c) == IS_CONSTANT_AST) {
170	558	zend_ast *ast = Z_ASTVAL_P(c);
171	558	if (ast->kind != ZEND_AST_CONSTANT
172	112	\|\| !zend_optimizer_get_persistent_constant(zend_ast_get_constant_name(ast), &result, true)
173	558	\|\| Z_TYPE(result) == IS_CONSTANT_AST) {
174	558	break;
175	558	}
176	1.08k	} else {
177	1.08k	ZVAL_COPY_OR_DUP(&result, c);
178	1.08k	}
179	1.08k	replace_by_const_or_qm_assign(op_array, opline, &result);
180	1.08k	break;
181	1.64k	}
182
183	0	case ZEND_DO_ICALL: {
184	0	zend_op *send1_opline = opline - 1;
185	0	zend_op *send2_opline = NULL;
186	0	zend_op *init_opline = NULL;
187
188	0	while (send1_opline->opcode == ZEND_NOP) {
189	0	send1_opline--;
190	0	}
191	0	if (send1_opline->opcode != ZEND_SEND_VAL \|\|
192	0	send1_opline->op1_type != IS_CONST) {
193		/* don't collect constants after unknown function call */
194	0	collect_constants = false;
195	0	break;
196	0	}
197	0	if (send1_opline->op2.num == 2) {
198	0	send2_opline = send1_opline;
199	0	send1_opline--;
200	0	while (send1_opline->opcode == ZEND_NOP) {
201	0	send1_opline--;
202	0	}
203	0	if (send1_opline->opcode != ZEND_SEND_VAL \|\|
204	0	send1_opline->op1_type != IS_CONST) {
205		/* don't collect constants after unknown function call */
206	0	collect_constants = false;
207	0	break;
208	0	}
209	0	}
210	0	init_opline = send1_opline - 1;
211	0	while (init_opline->opcode == ZEND_NOP) {
212	0	init_opline--;
213	0	}
214	0	if (init_opline->opcode != ZEND_INIT_FCALL \|\|
215	0	init_opline->op2_type != IS_CONST \|\|
216	0	Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) {
217		/* don't collect constants after unknown function call */
218	0	collect_constants = false;
219	0	break;
220	0	}
221
222		/* define("name", scalar); */
223	0	if (zend_string_equals_literal_ci(Z_STR(ZEND_OP2_LITERAL(init_opline)), "define")) {
224
225	0	if (Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING && send2_opline) {
226
227	0	if (collect_constants) {
228	0	zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(send1_opline), &ZEND_OP1_LITERAL(send2_opline));
229	0	}
230
231	0	if (RESULT_UNUSED(opline) &&
232	0	!zend_memnstr(Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)), "::", sizeof("::") - 1, Z_STRVAL(ZEND_OP1_LITERAL(send1_opline)) + Z_STRLEN(ZEND_OP1_LITERAL(send1_opline)))) {
233
234	0	opline->opcode = ZEND_DECLARE_CONST;
235	0	opline->op1_type = IS_CONST;
236	0	opline->op2_type = IS_CONST;
237	0	opline->result_type = IS_UNUSED;
238	0	opline->op1.constant = send1_opline->op1.constant;
239	0	opline->op2.constant = send2_opline->op1.constant;
240	0	opline->result.num = 0;
241
242	0	literal_dtor(&ZEND_OP2_LITERAL(init_opline));
243	0	MAKE_NOP(init_opline);
244	0	MAKE_NOP(send1_opline);
245	0	MAKE_NOP(send2_opline);
246	0	}
247	0	break;
248	0	}
249	0	}
250
251	0	if (!send2_opline && Z_TYPE(ZEND_OP1_LITERAL(send1_opline)) == IS_STRING &&
252	0	zend_optimizer_eval_special_func_call(&result, Z_STR(ZEND_OP2_LITERAL(init_opline)), Z_STR(ZEND_OP1_LITERAL(send1_opline))) == SUCCESS) {
253	0	literal_dtor(&ZEND_OP2_LITERAL(init_opline));
254	0	MAKE_NOP(init_opline);
255	0	literal_dtor(&ZEND_OP1_LITERAL(send1_opline));
256	0	MAKE_NOP(send1_opline);
257	0	replace_by_const_or_qm_assign(op_array, opline, &result);
258	0	break;
259	0	}
260
261		/* don't collect constants after any other function call */
262	0	collect_constants = false;
263	0	break;
264	0	}
265	10.4k	case ZEND_DO_UCALL:
266	216k	case ZEND_DO_FCALL:
267	216k	case ZEND_DO_FCALL_BY_NAME:
268	216k	case ZEND_FRAMELESS_ICALL_0:
269	216k	case ZEND_FRAMELESS_ICALL_1:
270	216k	case ZEND_FRAMELESS_ICALL_2:
271	216k	case ZEND_FRAMELESS_ICALL_3:
272		/* don't collect constants after any UCALL/FCALL/FRAMELESS ICALL */
273	216k	collect_constants = 0;
274	216k	break;
275	2.48k	case ZEND_STRLEN:
276	2.48k	if (opline->op1_type == IS_CONST &&
277	10	zend_optimizer_eval_strlen(&result, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
278	0	replace_by_const_or_qm_assign(op_array, opline, &result);
279	0	}
280	2.48k	break;
281	113	case ZEND_DEFINED:
282	113	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &result, false)) {
283	113	break;
284	113	}
285	0	ZVAL_TRUE(&result);
286	0	literal_dtor(&ZEND_OP1_LITERAL(opline));
287	0	replace_by_const_or_qm_assign(op_array, opline, &result);
288	0	break;
289	1.44k	case ZEND_DECLARE_CONST:
290	1.44k	if (collect_constants &&
291	0	Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
292	0	Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_CONSTANT_AST) {
293	0	zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline));
294	0	}
295	1.44k	break;
296
297	2.99k	case ZEND_JMPZ_EX:
298	6.19k	case ZEND_JMPNZ_EX:
299		/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
300		in case we know it wouldn't jump */
301	6.19k	if (opline->op1_type == IS_CONST) {
302	0	if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
303	0	if (opline->opcode == ZEND_JMPZ_EX) {
304	0	opline->opcode = ZEND_QM_ASSIGN;
305	0	zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
306	0	ZVAL_TRUE(&ZEND_OP1_LITERAL(opline));
307	0	opline->op2.num = 0;
308	0	break;
309	0	}
310	0	} else {
311	0	if (opline->opcode == ZEND_JMPNZ_EX) {
312	0	opline->opcode = ZEND_QM_ASSIGN;
313	0	zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
314	0	ZVAL_FALSE(&ZEND_OP1_LITERAL(opline));
315	0	opline->op2.num = 0;
316	0	break;
317	0	}
318	0	}
319	0	}
320	6.19k	collect_constants = false;
321	6.19k	break;
322
323	18.4k	case ZEND_JMPZ:
324	29.0k	case ZEND_JMPNZ:
325	29.0k	if (opline->op1_type == IS_CONST) {
326	1.86k	bool should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
327
328	1.86k	if (opline->opcode == ZEND_JMPZ) {
329	427	should_jmp = !should_jmp;
330	427	}
331	1.86k	literal_dtor(&ZEND_OP1_LITERAL(opline));
332	1.86k	opline->op1_type = IS_UNUSED;
333	1.86k	if (should_jmp) {
334	1.41k	opline->opcode = ZEND_JMP;
335	1.41k	COPY_NODE(opline->op1, opline->op2);
336	1.41k	opline->op2.num = 0;
337	1.41k	} else {
338	457	MAKE_NOP(opline);
339	457	break;
340	457	}
341	1.86k	}
342	28.5k	collect_constants = false;
343	28.5k	break;
344
345	105k	case ZEND_RETURN:
346	107k	case ZEND_RETURN_BY_REF:
347	109k	case ZEND_GENERATOR_RETURN:
348	111k	case ZEND_THROW:
349	112k	case ZEND_MATCH_ERROR:
350	141k	case ZEND_CATCH:
351	142k	case ZEND_FAST_CALL:
352	142k	case ZEND_FAST_RET:
353	204k	case ZEND_JMP:
354	216k	case ZEND_FE_RESET_R:
355	217k	case ZEND_FE_RESET_RW:
356	230k	case ZEND_FE_FETCH_R:
357	231k	case ZEND_FE_FETCH_RW:
358	233k	case ZEND_JMP_SET:
359	237k	case ZEND_COALESCE:
360	239k	case ZEND_ASSERT_CHECK:
361	269k	case ZEND_JMP_NULL:
362	269k	case ZEND_VERIFY_NEVER_TYPE:
363	269k	case ZEND_BIND_INIT_STATIC_OR_JMP:
364	269k	case ZEND_JMP_FRAMELESS:
365	269k	collect_constants = false;
366	269k	break;
367	2.36M	}
368	2.36M	opline++;
369	2.36M	}
370	94.6k	}