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

Source
/*
   +----------------------------------------------------------------------+
   | Zend Engine, DFG - Data Flow Graph                                   |
   +----------------------------------------------------------------------+
   | 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: Dmitry Stogov <dmitry@php.net>                              |
   +----------------------------------------------------------------------+
*/

#include "zend_compile.h"
#include "zend_dfg.h"

static zend_always_inline void zend_dfg_add_use_def_op_impl(const zend_op_array *op_array, const zend_op *opline, uint32_t build_flags, zend_bitset use, zend_bitset def) /* {{{ */
{
  uint32_t var_num;
  const zend_op *next;

  if (opline->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
    var_num = EX_VAR_TO_NUM(opline->op1.var);
    if (!zend_bitset_in(def, var_num)) {
      zend_bitset_incl(use, var_num);
    }
  }
  if (((opline->op2_type & (IS_VAR|IS_TMP_VAR)) != 0
    && opline->opcode != ZEND_FE_FETCH_R
    && opline->opcode != ZEND_FE_FETCH_RW)
   || (opline->op2_type == IS_CV)) {
    var_num = EX_VAR_TO_NUM(opline->op2.var);
    if (!zend_bitset_in(def, var_num)) {
      zend_bitset_incl(use, var_num);
    }
  }
  if ((build_flags & ZEND_SSA_USE_CV_RESULTS)
   && opline->result_type == IS_CV
   && opline->opcode != ZEND_RECV) {
    var_num = EX_VAR_TO_NUM(opline->result.var);
    if (!zend_bitset_in(def, var_num)) {
      zend_bitset_incl(use, var_num);
    }
  }

  switch (opline->opcode) {
    case ZEND_ASSIGN:
      if ((build_flags & ZEND_SSA_RC_INFERENCE) && opline->op2_type == IS_CV) {
        zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
      }
      if (opline->op1_type == IS_CV) {
add_op1_def:
        zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op1.var));
      }
      break;
    case ZEND_ASSIGN_REF:
      if (opline->op2_type == IS_CV) {
        zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
      }
      if (opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_ASSIGN_DIM:
    case ZEND_ASSIGN_OBJ:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
        if (build_flags & ZEND_SSA_RC_INFERENCE && next->op1_type == IS_CV) {
          zend_bitset_incl(def, var_num);
        }
      }
      if (opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_ASSIGN_OBJ_REF:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
        if (next->op1_type == IS_CV) {
          zend_bitset_incl(def, var_num);
        }
      }
      if (opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_ASSIGN_STATIC_PROP:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
        if ((build_flags & ZEND_SSA_RC_INFERENCE) && next->op1_type == IS_CV) {
          zend_bitset_incl(def, var_num);
        }
      }
      break;
    case ZEND_ASSIGN_STATIC_PROP_REF:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
        if (next->op1_type == IS_CV) {
          zend_bitset_incl(def, var_num);
        }
      }
      break;
    case ZEND_ASSIGN_STATIC_PROP_OP:
    case ZEND_FRAMELESS_ICALL_3:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
      }
      break;
    case ZEND_ASSIGN_DIM_OP:
    case ZEND_ASSIGN_OBJ_OP:
      next = opline + 1;
      if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
        var_num = EX_VAR_TO_NUM(next->op1.var);
        if (!zend_bitset_in(def, var_num)) {
          zend_bitset_incl(use, var_num);
        }
      }
      if (opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_ASSIGN_OP:
    case ZEND_PRE_INC:
    case ZEND_PRE_DEC:
    case ZEND_POST_INC:
    case ZEND_POST_DEC:
    case ZEND_BIND_GLOBAL:
    case ZEND_BIND_STATIC:
    case ZEND_BIND_INIT_STATIC_OR_JMP:
    case ZEND_SEND_VAR_NO_REF:
    case ZEND_SEND_VAR_NO_REF_EX:
    case ZEND_SEND_VAR_EX:
    case ZEND_SEND_FUNC_ARG:
    case ZEND_SEND_REF:
    case ZEND_SEND_UNPACK:
    case ZEND_FE_RESET_RW:
    case ZEND_MAKE_REF:
    case ZEND_PRE_INC_OBJ:
    case ZEND_PRE_DEC_OBJ:
    case ZEND_POST_INC_OBJ:
    case ZEND_POST_DEC_OBJ:
    case ZEND_UNSET_DIM:
    case ZEND_UNSET_OBJ:
    case ZEND_FETCH_DIM_W:
    case ZEND_FETCH_DIM_RW:
    case ZEND_FETCH_DIM_FUNC_ARG:
    case ZEND_FETCH_DIM_UNSET:
    case ZEND_FETCH_LIST_W:
      if (opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_SEND_VAR:
    case ZEND_CAST:
    case ZEND_QM_ASSIGN:
    case ZEND_JMP_SET:
    case ZEND_COALESCE:
    case ZEND_FE_RESET_R:
      if ((build_flags & ZEND_SSA_RC_INFERENCE) && opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_ADD_ARRAY_UNPACK:
      var_num = EX_VAR_TO_NUM(opline->result.var);
      if (!zend_bitset_in(def, var_num)) {
        zend_bitset_incl(use, var_num);
      }
      break;
    case ZEND_ADD_ARRAY_ELEMENT:
      var_num = EX_VAR_TO_NUM(opline->result.var);
      if (!zend_bitset_in(def, var_num)) {
        zend_bitset_incl(use, var_num);
      }
      ZEND_FALLTHROUGH;
    case ZEND_INIT_ARRAY:
      if (((build_flags & ZEND_SSA_RC_INFERENCE)
            || (opline->extended_value & ZEND_ARRAY_ELEMENT_REF))
          && opline->op1_type == IS_CV) {
        goto add_op1_def;
      }
      break;
    case ZEND_YIELD:
      if (opline->op1_type == IS_CV
          && ((op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)
            || (build_flags & ZEND_SSA_RC_INFERENCE))) {
        goto add_op1_def;
      }
      break;
    case ZEND_UNSET_CV:
      goto add_op1_def;
    case ZEND_VERIFY_RETURN_TYPE:
      if (opline->op1_type & (IS_TMP_VAR|IS_VAR|IS_CV)) {
        goto add_op1_def;
      }
      break;
    case ZEND_FE_FETCH_R:
    case ZEND_FE_FETCH_RW:
#if 0
      /* This special case was handled above the switch */
      if (opline->op2_type != IS_CV) {
        op2_use = -1; /* not used */
      }
#endif
      zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
      break;
    case ZEND_BIND_LEXICAL:
      if ((opline->extended_value & ZEND_BIND_REF) || (build_flags & ZEND_SSA_RC_INFERENCE)) {
        zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
      }
      break;
    default:
      break;
  }

  if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
    zend_bitset_incl(def, EX_VAR_TO_NUM(opline->result.var));
  }
}
/* }}} */

ZEND_API void zend_dfg_add_use_def_op(const zend_op_array *op_array, const zend_op *opline, uint32_t build_flags, zend_bitset use, zend_bitset def) /* {{{ */
{
  zend_dfg_add_use_def_op_impl(op_array, opline, build_flags, use, def);
}
/* }}} */

void zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, const zend_dfg *dfg, uint32_t build_flags) /* {{{ */
{
  uint32_t set_size = dfg->size;
  zend_basic_block *blocks = cfg->blocks;
  uint32_t blocks_count = cfg->blocks_count;
  zend_bitset tmp, def, use, in, out;
  uint32_t j;

  tmp = dfg->tmp;
  def = dfg->def;
  use = dfg->use;
  in  = dfg->in;
  out = dfg->out;

  /* Collect "def" and "use" sets */
  for (j = 0; j < blocks_count; j++) {
    const zend_op *opline, *end;
    zend_bitset b_use, b_def;

    if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) {
      continue;
    }

    opline = op_array->opcodes + blocks[j].start;
    end = opline + blocks[j].len;
    b_use = DFG_BITSET(use, set_size, j);
    b_def = DFG_BITSET(def, set_size, j);
    for (; opline < end; opline++) {
      if (opline->opcode != ZEND_OP_DATA) {
        zend_dfg_add_use_def_op_impl(op_array, opline, build_flags, b_use, b_def);
      }
    }
  }

  /* Calculate "in" and "out" sets */
  {
    uint32_t worklist_len = zend_bitset_len(blocks_count);
    zend_bitset worklist;
    ALLOCA_FLAG(use_heap);
    worklist = ZEND_BITSET_ALLOCA(worklist_len, use_heap);
    memset(worklist, 0, worklist_len * ZEND_BITSET_ELM_SIZE);
    for (j = 0; j < blocks_count; j++) {
      zend_bitset_incl(worklist, j);
    }
    while (!zend_bitset_empty(worklist, worklist_len)) {
      /* We use the last block on the worklist, because predecessors tend to be located
       * before the succeeding block, so this converges faster. */
      j = zend_bitset_last(worklist, worklist_len);
      zend_bitset_excl(worklist, j);

      if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) {
        continue;
      }
      if (blocks[j].successors_count != 0) {
        zend_bitset_copy(DFG_BITSET(out, set_size, j), DFG_BITSET(in, set_size, blocks[j].successors[0]), set_size);
        for (uint32_t k = 1; k < blocks[j].successors_count; k++) {
          zend_bitset_union(DFG_BITSET(out, set_size, j), DFG_BITSET(in, set_size, blocks[j].successors[k]), set_size);
        }
      } else {
        zend_bitset_clear(DFG_BITSET(out, set_size, j), set_size);
      }
      zend_bitset_union_with_difference(tmp, DFG_BITSET(use, set_size, j), DFG_BITSET(out, set_size, j), DFG_BITSET(def, set_size, j), set_size);
      if (!zend_bitset_equal(DFG_BITSET(in, set_size, j), tmp, set_size)) {
        zend_bitset_copy(DFG_BITSET(in, set_size, j), tmp, set_size);

        /* Add predecessors of changed block to worklist */
        {
          const int *predecessors = &cfg->predecessors[blocks[j].predecessor_offset];
          for (uint32_t k = 0; k < blocks[j].predecessors_count; k++) {
            zend_bitset_incl(worklist, predecessors[k]);
          }
        }
      }
    }

    free_alloca(worklist, use_heap);
  }
}
/* }}} */

Coverage Report

Created: 2026-07-25 06:39

Line	Count	Source
1		/*
2		+----------------------------------------------------------------------+
3		\| Zend Engine, DFG - Data Flow Graph \|
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: Dmitry Stogov <dmitry@php.net> \|
14		+----------------------------------------------------------------------+
15		*/
16
17		#include "zend_compile.h"
18		#include "zend_dfg.h"
19
20		static zend_always_inline void zend_dfg_add_use_def_op_impl(const zend_op_array op_array, const zend_op opline, uint32_t build_flags, zend_bitset use, zend_bitset def) /* {{{ */
21	1.83M	{
22	1.83M	uint32_t var_num;
23	1.83M	const zend_op *next;
24
25	1.83M	if (opline->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
26	1.07M	var_num = EX_VAR_TO_NUM(opline->op1.var);
27	1.07M	if (!zend_bitset_in(def, var_num)) {
28	297k	zend_bitset_incl(use, var_num);
29	297k	}
30	1.07M	}
31	1.83M	if (((opline->op2_type & (IS_VAR\|IS_TMP_VAR)) != 0
32	156k	&& opline->opcode != ZEND_FE_FETCH_R
33	156k	&& opline->opcode != ZEND_FE_FETCH_RW)
34	1.67M	\|\| (opline->op2_type == IS_CV)) {
35	338k	var_num = EX_VAR_TO_NUM(opline->op2.var);
36	338k	if (!zend_bitset_in(def, var_num)) {
37	196k	zend_bitset_incl(use, var_num);
38	196k	}
39	338k	}
40	1.83M	if ((build_flags & ZEND_SSA_USE_CV_RESULTS)
41	0	&& opline->result_type == IS_CV
42	0	&& opline->opcode != ZEND_RECV) {
43	0	var_num = EX_VAR_TO_NUM(opline->result.var);
44	0	if (!zend_bitset_in(def, var_num)) {
45	0	zend_bitset_incl(use, var_num);
46	0	}
47	0	}
48
49	1.83M	switch (opline->opcode) {
50	81.3k	case ZEND_ASSIGN:
51	81.3k	if ((build_flags & ZEND_SSA_RC_INFERENCE) && opline->op2_type == IS_CV) {
52	0	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
53	0	}
54	81.3k	if (opline->op1_type == IS_CV) {
55	154k	add_op1_def:
56	154k	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op1.var));
57	154k	}
58	154k	break;
59	154k	case ZEND_ASSIGN_REF:
60	3.58k	if (opline->op2_type == IS_CV) {
61	1.92k	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
62	1.92k	}
63	3.58k	if (opline->op1_type == IS_CV) {
64	2.78k	goto add_op1_def;
65	2.78k	}
66	802	break;
67	13.1k	case ZEND_ASSIGN_DIM:
68	25.1k	case ZEND_ASSIGN_OBJ:
69	25.1k	next = opline + 1;
70	25.1k	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
71	15.0k	var_num = EX_VAR_TO_NUM(next->op1.var);
72	15.0k	if (!zend_bitset_in(def, var_num)) {
73	2.43k	zend_bitset_incl(use, var_num);
74	2.43k	}
75	15.0k	if (build_flags & ZEND_SSA_RC_INFERENCE && next->op1_type == IS_CV) {
76	0	zend_bitset_incl(def, var_num);
77	0	}
78	15.0k	}
79	25.1k	if (opline->op1_type == IS_CV) {
80	15.6k	goto add_op1_def;
81	15.6k	}
82	9.40k	break;
83	9.40k	case ZEND_ASSIGN_OBJ_REF:
84	478	next = opline + 1;
85	478	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
86	478	var_num = EX_VAR_TO_NUM(next->op1.var);
87	478	if (!zend_bitset_in(def, var_num)) {
88	106	zend_bitset_incl(use, var_num);
89	106	}
90	478	if (next->op1_type == IS_CV) {
91	336	zend_bitset_incl(def, var_num);
92	336	}
93	478	}
94	478	if (opline->op1_type == IS_CV) {
95	224	goto add_op1_def;
96	224	}
97	254	break;
98	1.31k	case ZEND_ASSIGN_STATIC_PROP:
99	1.31k	next = opline + 1;
100	1.31k	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
101	749	var_num = EX_VAR_TO_NUM(next->op1.var);
102	749	if (!zend_bitset_in(def, var_num)) {
103	240	zend_bitset_incl(use, var_num);
104	240	}
105	749	if ((build_flags & ZEND_SSA_RC_INFERENCE) && next->op1_type == IS_CV) {
106	0	zend_bitset_incl(def, var_num);
107	0	}
108	749	}
109	1.31k	break;
110	194	case ZEND_ASSIGN_STATIC_PROP_REF:
111	194	next = opline + 1;
112	194	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
113	194	var_num = EX_VAR_TO_NUM(next->op1.var);
114	194	if (!zend_bitset_in(def, var_num)) {
115	10	zend_bitset_incl(use, var_num);
116	10	}
117	194	if (next->op1_type == IS_CV) {
118	56	zend_bitset_incl(def, var_num);
119	56	}
120	194	}
121	194	break;
122	28	case ZEND_ASSIGN_STATIC_PROP_OP:
123	28	case ZEND_FRAMELESS_ICALL_3:
124	28	next = opline + 1;
125	28	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
126	6	var_num = EX_VAR_TO_NUM(next->op1.var);
127	6	if (!zend_bitset_in(def, var_num)) {
128	4	zend_bitset_incl(use, var_num);
129	4	}
130	6	}
131	28	break;
132	2.38k	case ZEND_ASSIGN_DIM_OP:
133	3.29k	case ZEND_ASSIGN_OBJ_OP:
134	3.29k	next = opline + 1;
135	3.29k	if (next->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
136	1.74k	var_num = EX_VAR_TO_NUM(next->op1.var);
137	1.74k	if (!zend_bitset_in(def, var_num)) {
138	359	zend_bitset_incl(use, var_num);
139	359	}
140	1.74k	}
141	3.29k	if (opline->op1_type == IS_CV) {
142	2.62k	goto add_op1_def;
143	2.62k	}
144	666	break;
145	7.28k	case ZEND_ASSIGN_OP:
146	13.7k	case ZEND_PRE_INC:
147	14.9k	case ZEND_PRE_DEC:
148	16.4k	case ZEND_POST_INC:
149	18.2k	case ZEND_POST_DEC:
150	19.3k	case ZEND_BIND_GLOBAL:
151	28.8k	case ZEND_BIND_STATIC:
152	29.0k	case ZEND_BIND_INIT_STATIC_OR_JMP:
153	29.6k	case ZEND_SEND_VAR_NO_REF:
154	31.3k	case ZEND_SEND_VAR_NO_REF_EX:
155	38.8k	case ZEND_SEND_VAR_EX:
156	39.9k	case ZEND_SEND_FUNC_ARG:
157	42.9k	case ZEND_SEND_REF:
158	44.1k	case ZEND_SEND_UNPACK:
159	45.0k	case ZEND_FE_RESET_RW:
160	46.2k	case ZEND_MAKE_REF:
161	46.8k	case ZEND_PRE_INC_OBJ:
162	47.0k	case ZEND_PRE_DEC_OBJ:
163	47.1k	case ZEND_POST_INC_OBJ:
164	47.2k	case ZEND_POST_DEC_OBJ:
165	48.7k	case ZEND_UNSET_DIM:
166	49.7k	case ZEND_UNSET_OBJ:
167	55.3k	case ZEND_FETCH_DIM_W:
168	56.1k	case ZEND_FETCH_DIM_RW:
169	56.8k	case ZEND_FETCH_DIM_FUNC_ARG:
170	57.0k	case ZEND_FETCH_DIM_UNSET:
171	57.4k	case ZEND_FETCH_LIST_W:
172	57.4k	if (opline->op1_type == IS_CV) {
173	46.6k	goto add_op1_def;
174	46.6k	}
175	10.8k	break;
176	26.9k	case ZEND_SEND_VAR:
177	29.9k	case ZEND_CAST:
178	44.3k	case ZEND_QM_ASSIGN:
179	46.7k	case ZEND_JMP_SET:
180	51.1k	case ZEND_COALESCE:
181	55.1k	case ZEND_FE_RESET_R:
182	55.1k	if ((build_flags & ZEND_SSA_RC_INFERENCE) && opline->op1_type == IS_CV) {
183	0	goto add_op1_def;
184	0	}
185	55.1k	break;
186	55.1k	case ZEND_ADD_ARRAY_UNPACK:
187	249	var_num = EX_VAR_TO_NUM(opline->result.var);
188	249	if (!zend_bitset_in(def, var_num)) {
189	0	zend_bitset_incl(use, var_num);
190	0	}
191	249	break;
192	22.3k	case ZEND_ADD_ARRAY_ELEMENT:
193	22.3k	var_num = EX_VAR_TO_NUM(opline->result.var);
194	22.3k	if (!zend_bitset_in(def, var_num)) {
195	1.09k	zend_bitset_incl(use, var_num);
196	1.09k	}
197	22.3k	ZEND_FALLTHROUGH;
198	27.2k	case ZEND_INIT_ARRAY:
199	27.2k	if (((build_flags & ZEND_SSA_RC_INFERENCE)
200	27.2k	\|\| (opline->extended_value & ZEND_ARRAY_ELEMENT_REF))
201	355	&& opline->op1_type == IS_CV) {
202	330	goto add_op1_def;
203	330	}
204	26.9k	break;
205	26.9k	case ZEND_YIELD:
206	2.21k	if (opline->op1_type == IS_CV
207	390	&& ((op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)
208	324	\|\| (build_flags & ZEND_SSA_RC_INFERENCE))) {
209	66	goto add_op1_def;
210	66	}
211	2.14k	break;
212	2.37k	case ZEND_UNSET_CV:
213	2.37k	goto add_op1_def;
214	4.45k	case ZEND_VERIFY_RETURN_TYPE:
215	4.45k	if (opline->op1_type & (IS_TMP_VAR\|IS_VAR\|IS_CV)) {
216	2.44k	goto add_op1_def;
217	2.44k	}
218	2.01k	break;
219	3.97k	case ZEND_FE_FETCH_R:
220	4.92k	case ZEND_FE_FETCH_RW:
221		#if 0
222		/* This special case was handled above the switch */
223		if (opline->op2_type != IS_CV) {
224		op2_use = -1; /* not used */
225		}
226		#endif
227	4.92k	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
228	4.92k	break;
229	8.73k	case ZEND_BIND_LEXICAL:
230	8.73k	if ((opline->extended_value & ZEND_BIND_REF) \|\| (build_flags & ZEND_SSA_RC_INFERENCE)) {
231	614	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->op2.var));
232	614	}
233	8.73k	break;
234	1.55M	default:
235	1.55M	break;
236	1.83M	}
237
238	1.83M	if (opline->result_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
239	970k	zend_bitset_incl(def, EX_VAR_TO_NUM(opline->result.var));
240	970k	}
241	1.83M	}
242		/* }}} */
243
244		ZEND_API void zend_dfg_add_use_def_op(const zend_op_array op_array, const zend_op opline, uint32_t build_flags, zend_bitset use, zend_bitset def) /* {{{ */
245	0	{
246	0	zend_dfg_add_use_def_op_impl(op_array, opline, build_flags, use, def);
247	0	}
248		/* }}} */
249
250		void zend_build_dfg(const zend_op_array op_array, const zend_cfg cfg, const zend_dfg dfg, uint32_t build_flags) / {{{ */
251	89.1k	{
252	89.1k	uint32_t set_size = dfg->size;
253	89.1k	zend_basic_block *blocks = cfg->blocks;
254	89.1k	uint32_t blocks_count = cfg->blocks_count;
255	89.1k	zend_bitset tmp, def, use, in, out;
256	89.1k	uint32_t j;
257
258	89.1k	tmp = dfg->tmp;
259	89.1k	def = dfg->def;
260	89.1k	use = dfg->use;
261	89.1k	in = dfg->in;
262	89.1k	out = dfg->out;
263
264		/* Collect "def" and "use" sets */
265	350k	for (j = 0; j < blocks_count; j++) {
266	261k	const zend_op opline, end;
267	261k	zend_bitset b_use, b_def;
268
269	261k	if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) {
270	34	continue;
271	34	}
272
273	261k	opline = op_array->opcodes + blocks[j].start;
274	261k	end = opline + blocks[j].len;
275	261k	b_use = DFG_BITSET(use, set_size, j);
276	261k	b_def = DFG_BITSET(def, set_size, j);
277	2.12M	for (; opline < end; opline++) {
278	1.86M	if (opline->opcode != ZEND_OP_DATA) {
279	1.83M	zend_dfg_add_use_def_op_impl(op_array, opline, build_flags, b_use, b_def);
280	1.83M	}
281	1.86M	}
282	261k	}
283
284		/* Calculate "in" and "out" sets */
285	89.1k	{
286	89.1k	uint32_t worklist_len = zend_bitset_len(blocks_count);
287	89.1k	zend_bitset worklist;
288	89.1k	ALLOCA_FLAG(use_heap);
289	89.1k	worklist = ZEND_BITSET_ALLOCA(worklist_len, use_heap);
290	89.1k	memset(worklist, 0, worklist_len * ZEND_BITSET_ELM_SIZE);
291	350k	for (j = 0; j < blocks_count; j++) {
292	261k	zend_bitset_incl(worklist, j);
293	261k	}
294	432k	while (!zend_bitset_empty(worklist, worklist_len)) {
295		/* We use the last block on the worklist, because predecessors tend to be located
296		* before the succeeding block, so this converges faster. */
297	343k	j = zend_bitset_last(worklist, worklist_len);
298	343k	zend_bitset_excl(worklist, j);
299
300	343k	if ((blocks[j].flags & ZEND_BB_REACHABLE) == 0) {
301	34	continue;
302	34	}
303	343k	if (blocks[j].successors_count != 0) {
304	251k	zend_bitset_copy(DFG_BITSET(out, set_size, j), DFG_BITSET(in, set_size, blocks[j].successors[0]), set_size);
305	384k	for (uint32_t k = 1; k < blocks[j].successors_count; k++) {
306	132k	zend_bitset_union(DFG_BITSET(out, set_size, j), DFG_BITSET(in, set_size, blocks[j].successors[k]), set_size);
307	132k	}
308	251k	} else {
309	91.7k	zend_bitset_clear(DFG_BITSET(out, set_size, j), set_size);
310	91.7k	}
311	343k	zend_bitset_union_with_difference(tmp, DFG_BITSET(use, set_size, j), DFG_BITSET(out, set_size, j), DFG_BITSET(def, set_size, j), set_size);
312	343k	if (!zend_bitset_equal(DFG_BITSET(in, set_size, j), tmp, set_size)) {
313	252k	zend_bitset_copy(DFG_BITSET(in, set_size, j), tmp, set_size);
314
315		/* Add predecessors of changed block to worklist */
316	252k	{
317	252k	const int *predecessors = &cfg->predecessors[blocks[j].predecessor_offset];
318	575k	for (uint32_t k = 0; k < blocks[j].predecessors_count; k++) {
319	322k	zend_bitset_incl(worklist, predecessors[k]);
320	322k	}
321	252k	}
322	252k	}
323	343k	}
324
325		free_alloca(worklist, use_heap);
326	89.1k	}
327	89.1k	}
328		/* }}} */