/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-12-14 06:09

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	25	#define TO_STRING_NOWARN(val) do { \
38	25	if (Z_TYPE_P(val) < IS_ARRAY) { \
39	19	convert_to_string(val); \
40	19	} \
41	25	} while (0)
42
43	1.10k	static void replace_by_const_or_qm_assign(zend_op_array op_array, zend_op opline, zval *result) {
44	1.10k	if (opline->op1_type == IS_CONST) {
45	1.09k	literal_dtor(&ZEND_OP1_LITERAL(opline));
46	1.09k	}
47	1.10k	if (opline->op2_type == IS_CONST) {
48	919	literal_dtor(&ZEND_OP2_LITERAL(opline));
49	919	}
50	1.10k	if (zend_optimizer_replace_by_const(op_array, opline + 1, opline->result_type, opline->result.var, result)) {
51	1.08k	MAKE_NOP(opline);
52	1.08k	} else {
53	28	opline->opcode = ZEND_QM_ASSIGN;
54	28	opline->extended_value = 0;
55	28	SET_UNUSED(opline->op2);
56	28	zend_optimizer_update_op1_const(op_array, opline, result);
57	28	}
58	1.10k	}
59
60		void zend_optimizer_pass1(zend_op_array op_array, zend_optimizer_ctx ctx)
61	54.8k	{
62	54.8k	zend_op *opline = op_array->opcodes;
63	54.8k	zend_op *end = opline + op_array->last;
64	54.8k	bool collect_constants = (ZEND_OPTIMIZER_PASS_15 & ctx->optimization_level)?
65	54.8k	(op_array == &ctx->script->main_op_array) : 0;
66	54.8k	zval result;
67
68	1.55M	while (opline < end) {
69	1.49M	switch (opline->opcode) {
70	31.9k	case ZEND_CONCAT:
71	35.3k	case ZEND_FAST_CONCAT:
72	35.3k	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	35.3k	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	35.3k	ZEND_FALLTHROUGH;
79	40.5k	case ZEND_ADD:
80	46.9k	case ZEND_SUB:
81	50.9k	case ZEND_MUL:
82	60.1k	case ZEND_DIV:
83	60.1k	case ZEND_POW:
84	62.9k	case ZEND_MOD:
85	64.9k	case ZEND_SL:
86	65.6k	case ZEND_SR:
87	66.4k	case ZEND_BW_OR:
88	73.1k	case ZEND_BW_AND:
89	77.3k	case ZEND_BW_XOR:
90	84.9k	case ZEND_IS_EQUAL:
91	86.2k	case ZEND_IS_NOT_EQUAL:
92	90.7k	case ZEND_IS_SMALLER:
93	92.7k	case ZEND_IS_SMALLER_OR_EQUAL:
94	94.0k	case ZEND_IS_IDENTICAL:
95	94.3k	case ZEND_IS_NOT_IDENTICAL:
96	95.2k	case ZEND_BOOL_XOR:
97	95.2k	case ZEND_SPACESHIP:
98	95.2k	case ZEND_CASE:
99	95.3k	case ZEND_CASE_STRICT:
100	95.3k	if (opline->op1_type == IS_CONST && opline->op2_type == IS_CONST &&
101	6.01k	zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
102	186	replace_by_const_or_qm_assign(op_array, opline, &result);
103	186	}
104	95.3k	break;
105
106	88.2k	case ZEND_ASSIGN_OP:
107	88.2k	if (opline->extended_value == ZEND_CONCAT && opline->op2_type == IS_CONST
108	130	&& Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
109	25	TO_STRING_NOWARN(&ZEND_OP2_LITERAL(opline));
110	25	}
111	88.2k	break;
112
113	1.50k	case ZEND_CAST:
114	1.50k	if (opline->op1_type == IS_CONST &&
115	340	zend_optimizer_eval_cast(&result, opline->extended_value, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
116	190	replace_by_const_or_qm_assign(op_array, opline, &result);
117	190	}
118	1.50k	break;
119
120	1.83k	case ZEND_BW_NOT:
121	11.0k	case ZEND_BOOL_NOT:
122	11.0k	if (opline->op1_type == IS_CONST &&
123	156	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	11.0k	break;
127
128	30.9k	case ZEND_FETCH_CONSTANT:
129	30.9k	if (opline->op2_type == IS_CONST &&
130	30.9k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
131	30.9k	zend_string_equals_literal(Z_STR(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__")) {
132		/* substitute __COMPILER_HALT_OFFSET__ constant */
133	4	zend_execute_data *orig_execute_data = EG(current_execute_data);
134	4	zend_execute_data fake_execute_data;
135	4	zval *offset;
136
137	4	memset(&fake_execute_data, 0, sizeof(zend_execute_data));
138	4	fake_execute_data.func = (zend_function*)op_array;
139	4	EG(current_execute_data) = &fake_execute_data;
140	4	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	4	EG(current_execute_data) = orig_execute_data;
146	4	break;
147	4	}
148
149	30.9k	if (opline->op2_type == IS_CONST &&
150	30.9k	Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
151		/* substitute persistent constants */
152	30.9k	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &result, true)) {
153	30.9k	if (!ctx->constants \|\| !zend_optimizer_get_collected_constant(ctx->constants, &ZEND_OP2_LITERAL(opline), &result)) {
154	30.9k	break;
155	30.9k	}
156	30.9k	}
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	2.37k	case ZEND_FETCH_CLASS_CONSTANT: {
165	2.37k	bool is_prototype;
166	2.37k	const zend_class_constant *cc = zend_fetch_class_const_info(ctx->script, op_array, opline, &is_prototype);
167	2.37k	if (!cc \|\| is_prototype) {
168	1.37k	break;
169	1.37k	}
170	999	const zval *c = &cc->value;
171	999	if (Z_TYPE_P(c) == IS_CONSTANT_AST) {
172	266	zend_ast *ast = Z_ASTVAL_P(c);
173	266	if (ast->kind != ZEND_AST_CONSTANT
174	56	\|\| !zend_optimizer_get_persistent_constant(zend_ast_get_constant_name(ast), &result, true)
175	266	\|\| Z_TYPE(result) == IS_CONSTANT_AST) {
176	266	break;
177	266	}
178	733	} else {
179	733	ZVAL_COPY_OR_DUP(&result, c);
180	733	}
181	733	replace_by_const_or_qm_assign(op_array, opline, &result);
182	733	break;
183	999	}
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	5.39k	case ZEND_DO_UCALL:
268	124k	case ZEND_DO_FCALL:
269	124k	case ZEND_DO_FCALL_BY_NAME:
270	124k	case ZEND_FRAMELESS_ICALL_0:
271	124k	case ZEND_FRAMELESS_ICALL_1:
272	124k	case ZEND_FRAMELESS_ICALL_2:
273	124k	case ZEND_FRAMELESS_ICALL_3:
274		/* don't collect constants after any UCALL/FCALL/FRAMELESS ICALL */
275	124k	collect_constants = 0;
276	124k	break;
277	1.17k	case ZEND_STRLEN:
278	1.17k	if (opline->op1_type == IS_CONST &&
279	6	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	1.17k	break;
283	44	case ZEND_DEFINED:
284	44	if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &result, false)) {
285	44	break;
286	44	}
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.12k	case ZEND_DECLARE_CONST:
292	1.12k	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.12k	break;
298
299	1.71k	case ZEND_JMPZ_EX:
300	4.02k	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	4.02k	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	4.02k	collect_constants = false;
323	4.02k	break;
324
325	10.0k	case ZEND_JMPZ:
326	15.1k	case ZEND_JMPNZ:
327	15.1k	if (opline->op1_type == IS_CONST) {
328	778	bool should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
329
330	778	if (opline->opcode == ZEND_JMPZ) {
331	255	should_jmp = !should_jmp;
332	255	}
333	778	literal_dtor(&ZEND_OP1_LITERAL(opline));
334	778	opline->op1_type = IS_UNUSED;
335	778	if (should_jmp) {
336	489	opline->opcode = ZEND_JMP;
337	489	COPY_NODE(opline->op1, opline->op2);
338	489	opline->op2.num = 0;
339	489	} else {
340	289	MAKE_NOP(opline);
341	289	break;
342	289	}
343	778	}
344	14.8k	collect_constants = false;
345	14.8k	break;
346
347	59.7k	case ZEND_RETURN:
348	60.7k	case ZEND_RETURN_BY_REF:
349	61.8k	case ZEND_GENERATOR_RETURN:
350	63.0k	case ZEND_THROW:
351	63.2k	case ZEND_MATCH_ERROR:
352	83.9k	case ZEND_CATCH:
353	84.4k	case ZEND_FAST_CALL:
354	84.8k	case ZEND_FAST_RET:
355	122k	case ZEND_JMP:
356	129k	case ZEND_FE_RESET_R:
357	130k	case ZEND_FE_RESET_RW:
358	138k	case ZEND_FE_FETCH_R:
359	138k	case ZEND_FE_FETCH_RW:
360	139k	case ZEND_JMP_SET:
361	142k	case ZEND_COALESCE:
362	142k	case ZEND_ASSERT_CHECK:
363	158k	case ZEND_JMP_NULL:
364	158k	case ZEND_VERIFY_NEVER_TYPE:
365	158k	case ZEND_BIND_INIT_STATIC_OR_JMP:
366	158k	case ZEND_JMP_FRAMELESS:
367	158k	collect_constants = false;
368	158k	break;
369	1.49M	}
370	1.49M	opline++;
371	1.49M	}
372	54.8k	}