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

Source (jump to first uncovered line)
/*
   +----------------------------------------------------------------------+
   | Zend OPcache                                                         |
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | 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, 1)) {
          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, 1)
         || 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 = 0;
        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 = 0;
          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 = 0;
        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 = 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, 0)) {
        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 = 0;
      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 = 0;
      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 = 0;
      break;
    }
    opline++;
  }
}

Coverage Report

Created: 2025-06-13 06:43

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