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

Source
/*
   +----------------------------------------------------------------------+
   | 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, 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: 2025-11-16 06:23

Line	Count	Source
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	41	#define TO_STRING_NOWARN(val) do { \
38	41	if (Z_TYPE_P(val) < IS_ARRAY) { \
39	27	convert_to_string(val); \
40	27	} \
41	41	} while (0)
42
43	2.53k	static void replace_by_const_or_qm_assign(zend_op_array op_array, zend_op opline, zval *result) {
44	2.53k	if (opline->op1_type == IS_CONST) {
45	2.51k	literal_dtor(&ZEND_OP1_LITERAL(opline));
46	2.51k	}
47	2.53k	if (opline->op2_type == IS_CONST) {
48	2.05k	literal_dtor(&ZEND_OP2_LITERAL(opline));
49	2.05k	}
50	2.53k	if (zend_optimizer_replace_by_const(op_array, opline + 1, opline->result_type, opline->result.var, result)) {
51	2.48k	MAKE_NOP(opline);
52	2.48k	} else {
53	54	opline->opcode = ZEND_QM_ASSIGN;
54	54	opline->extended_value = 0;
55	54	SET_UNUSED(opline->op2);
56	54	zend_optimizer_update_op1_const(op_array, opline, result);
57	54	}
58	2.53k	}
59
60		void zend_optimizer_pass1(zend_op_array op_array, zend_optimizer_ctx ctx)
61	98.6k	{
62	98.6k	zend_op *opline = op_array->opcodes;
63	98.6k	zend_op *end = opline + op_array->last;
64	98.6k	bool collect_constants = (ZEND_OPTIMIZER_PASS_15 & ctx->optimization_level)?
65	98.6k	(op_array == &ctx->script->main_op_array) : 0;
66	98.6k	zval result;
67
68	2.59M	while (opline < end) {
69	2.49M	switch (opline->opcode) {
70	52.0k	case ZEND_CONCAT:
71	57.1k	case ZEND_FAST_CONCAT:
72	57.1k	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	57.1k	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	57.1k	ZEND_FALLTHROUGH;
79	68.0k	case ZEND_ADD:
80	77.1k	case ZEND_SUB:
81	85.5k	case ZEND_MUL:
82	96.4k	case ZEND_DIV:
83	96.6k	case ZEND_POW:
84	100k	case ZEND_MOD:
85	103k	case ZEND_SL:
86	104k	case ZEND_SR:
87	105k	case ZEND_BW_OR:
88	113k	case ZEND_BW_AND:
89	119k	case ZEND_BW_XOR:
90	132k	case ZEND_IS_EQUAL:
91	135k	case ZEND_IS_NOT_EQUAL:
92	143k	case ZEND_IS_SMALLER:
93	145k	case ZEND_IS_SMALLER_OR_EQUAL:
94	148k	case ZEND_IS_IDENTICAL:
95	148k	case ZEND_IS_NOT_IDENTICAL:
96	150k	case ZEND_BOOL_XOR:
97	150k	case ZEND_SPACESHIP:
98	150k	case ZEND_CASE:
99	150k	case ZEND_CASE_STRICT:
100	150k	if (opline->op1_type == IS_CONST && opline->op2_type == IS_CONST &&
101	8.65k	zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
102	326	replace_by_const_or_qm_assign(op_array, opline, &result);
103	326	}
104	150k	break;
105
106	135k	case ZEND_ASSIGN_OP:
107	135k	if (opline->extended_value == ZEND_CONCAT && opline->op2_type == IS_CONST
108	188	&& Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
109	41	TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
110	41	}
111	135k	break;
112
113	2.93k	case ZEND_CAST:
114	2.93k	if (opline->op1_type == IS_CONST &&
115	789	zend_optimizer_eval_cast(&result, opline->extended_value, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
116	480	replace_by_const_or_qm_assign(op_array, opline, &result);
117	480	}
118	2.93k	break;
119
120	21.4k	case ZEND_BW_NOT:
121	32.9k	case ZEND_BOOL_NOT:
122	32.9k	if (opline->op1_type == IS_CONST &&
123	203	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	32.9k	break;
127
128	51.7k	case ZEND_FETCH_CONSTANT:
129	51.7k	if (opline->op2_type == IS_CONST &&
130	51.7k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
131	51.7k	zend_string_equals_literal(Z_STR(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__")) {
132		/* substitute __COMPILER_HALT_OFFSET__ constant */
133	14	zend_execute_data *orig_execute_data = EG(current_execute_data);
134	14	zend_execute_data fake_execute_data;
135	14	zval *offset;
136
137	14	memset(&fake_execute_data, 0, sizeof(zend_execute_data));
138	14	fake_execute_data.func = (zend_function*)op_array;
139	14	EG(current_execute_data) = &fake_execute_data;
140	14	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	14	EG(current_execute_data) = orig_execute_data;
146	14	break;
147	14	}
148
149	51.7k	if (opline->op2_type == IS_CONST &&
150	51.7k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
151		/* substitute persistent constants */
152	51.7k	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &result, true)) {
153	51.7k	if (!ctx->constants \|\| !zend_optimizer_get_collected_constant(ctx->constants, &ZEND_OP2_LITERAL(opline), &result)) {
154	51.7k	break;
155	51.7k	}
156	51.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.83k	case ZEND_FETCH_CLASS_CONSTANT: {
165	4.83k	bool is_prototype;
166	4.83k	const zend_class_constant *cc = zend_fetch_class_const_info(ctx->script, op_array, opline, &is_prototype);
167	4.83k	if (!cc \|\| is_prototype) {
168	2.55k	break;
169	2.55k	}
170	2.28k	const zval *c = &cc->value;
171	2.28k	if (Z_TYPE_P(c) == IS_CONSTANT_AST) {
172	556	zend_ast *ast = Z_ASTVAL_P(c);
173	556	if (ast->kind != ZEND_AST_CONSTANT
174	132	\|\| !zend_optimizer_get_persistent_constant(zend_ast_get_constant_name(ast), &result, true)
175	556	\|\| Z_TYPE(result) == IS_CONSTANT_AST) {
176	556	break;
177	556	}
178	1.73k	} else {
179	1.73k	ZVAL_COPY_OR_DUP(&result, c);
180	1.73k	}
181	1.73k	replace_by_const_or_qm_assign(op_array, opline, &result);
182	1.73k	break;
183	2.28k	}
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 = false;
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 = false;
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 = false;
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 = false;
265	0	break;
266	0	}
267	9.58k	case ZEND_DO_UCALL:
268	220k	case ZEND_DO_FCALL:
269	220k	case ZEND_DO_FCALL_BY_NAME:
270	220k	case ZEND_FRAMELESS_ICALL_0:
271	220k	case ZEND_FRAMELESS_ICALL_1:
272	220k	case ZEND_FRAMELESS_ICALL_2:
273	220k	case ZEND_FRAMELESS_ICALL_3:
274		/* don't collect constants after any UCALL/FCALL/FRAMELESS ICALL */
275	220k	collect_constants = 0;
276	220k	break;
277	2.13k	case ZEND_STRLEN:
278	2.13k	if (opline->op1_type == IS_CONST &&
279	10	zend_optimizer_eval_strlen(&result, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
280	0	replace_by_const_or_qm_assign(op_array, opline, &result);
281	0	}
282	2.13k	break;
283	83	case ZEND_DEFINED:
284	83	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &result, false)) {
285	83	break;
286	83	}
287	0	ZVAL_TRUE(&result);
288	0	literal_dtor(&ZEND_OP1_LITERAL(opline));
289	0	replace_by_const_or_qm_assign(op_array, opline, &result);
290	0	break;
291	1.86k	case ZEND_DECLARE_CONST:
292	1.86k	if (collect_constants &&
293	0	Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
294	0	Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_CONSTANT_AST) {
295	0	zend_optimizer_collect_constant(ctx, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline));
296	0	}
297	1.86k	break;
298
299	3.30k	case ZEND_JMPZ_EX:
300	6.74k	case ZEND_JMPNZ_EX:
301		/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
302		in case we know it wouldn't jump */
303	6.74k	if (opline->op1_type == IS_CONST) {
304	0	if (zend_is_true(&ZEND_OP1_LITERAL(opline))) {
305	0	if (opline->opcode == ZEND_JMPZ_EX) {
306	0	opline->opcode = ZEND_QM_ASSIGN;
307	0	zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
308	0	ZVAL_TRUE(&ZEND_OP1_LITERAL(opline));
309	0	opline->op2.num = 0;
310	0	break;
311	0	}
312	0	} else {
313	0	if (opline->opcode == ZEND_JMPNZ_EX) {
314	0	opline->opcode = ZEND_QM_ASSIGN;
315	0	zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
316	0	ZVAL_FALSE(&ZEND_OP1_LITERAL(opline));
317	0	opline->op2.num = 0;
318	0	break;
319	0	}
320	0	}
321	0	}
322	6.74k	collect_constants = false;
323	6.74k	break;
324
325	16.4k	case ZEND_JMPZ:
326	24.4k	case ZEND_JMPNZ:
327	24.4k	if (opline->op1_type == IS_CONST) {
328	1.40k	bool should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
329
330	1.40k	if (opline->opcode == ZEND_JMPZ) {
331	461	should_jmp = !should_jmp;
332	461	}
333	1.40k	literal_dtor(&ZEND_OP1_LITERAL(opline));
334	1.40k	opline->op1_type = IS_UNUSED;
335	1.40k	if (should_jmp) {
336	907	opline->opcode = ZEND_JMP;
337	907	COPY_NODE(opline->op1, opline->op2);
338	907	opline->op2.num = 0;
339	907	} else {
340	499	MAKE_NOP(opline);
341	499	break;
342	499	}
343	1.40k	}
344	23.9k	collect_constants = false;
345	23.9k	break;
346
347	107k	case ZEND_RETURN:
348	108k	case ZEND_RETURN_BY_REF:
349	111k	case ZEND_GENERATOR_RETURN:
350	113k	case ZEND_THROW:
351	113k	case ZEND_MATCH_ERROR:
352	147k	case ZEND_CATCH:
353	148k	case ZEND_FAST_CALL:
354	149k	case ZEND_FAST_RET:
355	211k	case ZEND_JMP:
356	223k	case ZEND_FE_RESET_R:
357	224k	case ZEND_FE_RESET_RW:
358	236k	case ZEND_FE_FETCH_R:
359	237k	case ZEND_FE_FETCH_RW:
360	238k	case ZEND_JMP_SET:
361	243k	case ZEND_COALESCE:
362	244k	case ZEND_ASSERT_CHECK:
363	276k	case ZEND_JMP_NULL:
364	276k	case ZEND_VERIFY_NEVER_TYPE:
365	276k	case ZEND_BIND_INIT_STATIC_OR_JMP:
366	276k	case ZEND_JMP_FRAMELESS:
367	276k	collect_constants = false;
368	276k	break;
369	2.49M	}
370	2.49M	opline++;
371	2.49M	}
372	98.6k	}