/src/php-src/Zend/Optimizer/escape_analysis.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | +----------------------------------------------------------------------+ |
3 | | | Zend OPcache, Escape Analysis | |
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: Dmitry Stogov <dmitry@php.net> | |
16 | | +----------------------------------------------------------------------+ |
17 | | */ |
18 | | |
19 | | #include "Optimizer/zend_optimizer.h" |
20 | | #include "Optimizer/zend_optimizer_internal.h" |
21 | | #include "zend_bitset.h" |
22 | | #include "zend_cfg.h" |
23 | | #include "zend_ssa.h" |
24 | | #include "zend_inference.h" |
25 | | #include "zend_dump.h" |
26 | | |
27 | | /* |
28 | | * T. Kotzmann and H. Mossenbock. Escape analysis in the context of dynamic |
29 | | * compilation and deoptimization. In Proceedings of the International |
30 | | * Conference on Virtual Execution Environments, pages 111-120, Chicago, |
31 | | * June 2005 |
32 | | */ |
33 | | |
34 | | static zend_always_inline void union_find_init(int *parent, int *size, int count) /* {{{ */ |
35 | 9.80k | { |
36 | 9.80k | int i; |
37 | | |
38 | 429k | for (i = 0; i < count; i++) { |
39 | 419k | parent[i] = i; |
40 | 419k | size[i] = 1; |
41 | 419k | } |
42 | 9.80k | } |
43 | | /* }}} */ |
44 | | |
45 | | static zend_always_inline int union_find_root(int *parent, int i) /* {{{ */ |
46 | 874k | { |
47 | 874k | int p = parent[i]; |
48 | | |
49 | 1.22M | while (i != p) { |
50 | 345k | p = parent[p]; |
51 | 345k | parent[i] = p; |
52 | 345k | i = p; |
53 | 345k | p = parent[i]; |
54 | 345k | } |
55 | 874k | return i; |
56 | 874k | } |
57 | | /* }}} */ |
58 | | |
59 | | static zend_always_inline void union_find_unite(int *parent, int *size, int i, int j) /* {{{ */ |
60 | 227k | { |
61 | 227k | int r1 = union_find_root(parent, i); |
62 | 227k | int r2 = union_find_root(parent, j); |
63 | | |
64 | 227k | if (r1 != r2) { |
65 | 171k | if (size[r1] < size[r2]) { |
66 | 83.7k | parent[r1] = r2; |
67 | 83.7k | size[r2] += size[r1]; |
68 | 87.3k | } else { |
69 | 87.3k | parent[r2] = r1; |
70 | 87.3k | size[r1] += size[r2]; |
71 | 87.3k | } |
72 | 171k | } |
73 | 227k | } |
74 | | /* }}} */ |
75 | | |
76 | | static zend_result zend_build_equi_escape_sets(int *parent, zend_op_array *op_array, zend_ssa *ssa) /* {{{ */ |
77 | 9.80k | { |
78 | 9.80k | zend_ssa_var *ssa_vars = ssa->vars; |
79 | 9.80k | int ssa_vars_count = ssa->vars_count; |
80 | 9.80k | zend_ssa_phi *p; |
81 | 9.80k | int i, j; |
82 | 9.80k | int *size; |
83 | 9.80k | ALLOCA_FLAG(use_heap) |
84 | | |
85 | 9.80k | size = do_alloca(sizeof(int) * ssa_vars_count, use_heap); |
86 | 9.80k | if (!size) { |
87 | 0 | return FAILURE; |
88 | 0 | } |
89 | 9.80k | union_find_init(parent, size, ssa_vars_count); |
90 | | |
91 | 429k | for (i = 0; i < ssa_vars_count; i++) { |
92 | 419k | if (ssa_vars[i].definition_phi) { |
93 | 78.7k | p = ssa_vars[i].definition_phi; |
94 | 78.7k | if (p->pi >= 0) { |
95 | 23.6k | union_find_unite(parent, size, i, p->sources[0]); |
96 | 55.0k | } else { |
97 | 167k | for (j = 0; j < ssa->cfg.blocks[p->block].predecessors_count; j++) { |
98 | 112k | union_find_unite(parent, size, i, p->sources[j]); |
99 | 112k | } |
100 | 55.0k | } |
101 | 340k | } else if (ssa_vars[i].definition >= 0) { |
102 | 311k | int def = ssa_vars[i].definition; |
103 | 311k | zend_ssa_op *op = ssa->ops + def; |
104 | 311k | zend_op *opline = op_array->opcodes + def; |
105 | | |
106 | 311k | if (op->op1_def >= 0) { |
107 | 61.6k | if (op->op1_use >= 0) { |
108 | 61.6k | if (opline->opcode != ZEND_ASSIGN) { |
109 | 30.9k | union_find_unite(parent, size, op->op1_def, op->op1_use); |
110 | 30.9k | } |
111 | 61.6k | } |
112 | 61.6k | if (opline->opcode == ZEND_ASSIGN && op->op2_use >= 0) { |
113 | 21.3k | union_find_unite(parent, size, op->op1_def, op->op2_use); |
114 | 21.3k | } |
115 | 61.6k | } |
116 | 311k | if (op->op2_def >= 0) { |
117 | 4.21k | if (op->op2_use >= 0) { |
118 | 4.02k | union_find_unite(parent, size, op->op2_def, op->op2_use); |
119 | 4.02k | } |
120 | 4.21k | } |
121 | 311k | if (op->result_def >= 0) { |
122 | 271k | if (op->result_use >= 0) { |
123 | 17.6k | if (opline->opcode != ZEND_QM_ASSIGN) { |
124 | 17.6k | union_find_unite(parent, size, op->result_def, op->result_use); |
125 | 17.6k | } |
126 | 17.6k | } |
127 | 271k | if (opline->opcode == ZEND_QM_ASSIGN && op->op1_use >= 0) { |
128 | 1.01k | union_find_unite(parent, size, op->result_def, op->op1_use); |
129 | 1.01k | } |
130 | 271k | if (opline->opcode == ZEND_ASSIGN && op->op2_use >= 0) { |
131 | 7.59k | union_find_unite(parent, size, op->result_def, op->op2_use); |
132 | 7.59k | } |
133 | 271k | if (opline->opcode == ZEND_ASSIGN && op->op1_def >= 0) { |
134 | 8.94k | union_find_unite(parent, size, op->result_def, op->op1_def); |
135 | 8.94k | } |
136 | 271k | } |
137 | 311k | } |
138 | 419k | } |
139 | | |
140 | 429k | for (i = 0; i < ssa_vars_count; i++) { |
141 | 419k | parent[i] = union_find_root(parent, i); |
142 | 419k | } |
143 | | |
144 | 9.80k | free_alloca(size, use_heap); |
145 | | |
146 | 9.80k | return SUCCESS; |
147 | 9.80k | } |
148 | | /* }}} */ |
149 | | |
150 | | static bool is_allocation_def(zend_op_array *op_array, zend_ssa *ssa, int def, int var, const zend_script *script) /* {{{ */ |
151 | 255k | { |
152 | 255k | zend_ssa_op *ssa_op = ssa->ops + def; |
153 | 255k | zend_op *opline = op_array->opcodes + def; |
154 | | |
155 | 255k | if (ssa_op->result_def == var) { |
156 | 195k | switch (opline->opcode) { |
157 | 5.56k | case ZEND_INIT_ARRAY: |
158 | 5.56k | return 1; |
159 | 27.2k | case ZEND_NEW: { |
160 | | /* objects with destructors should escape */ |
161 | 27.2k | zend_class_entry *ce = zend_optimizer_get_class_entry_from_op1( |
162 | 27.2k | script, op_array, opline); |
163 | 27.2k | uint32_t forbidden_flags = |
164 | | /* These flags will always cause an exception */ |
165 | 27.2k | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS |
166 | 27.2k | | ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT; |
167 | 27.2k | if (ce |
168 | 27.2k | && !ce->parent |
169 | 27.2k | && !ce->create_object |
170 | 27.2k | && ce->default_object_handlers->get_constructor == zend_std_get_constructor |
171 | 27.2k | && ce->default_object_handlers->dtor_obj == zend_objects_destroy_object |
172 | 27.2k | && !ce->constructor |
173 | 27.2k | && !ce->destructor |
174 | 27.2k | && !ce->__get |
175 | 27.2k | && !ce->__set |
176 | 27.2k | && !(ce->ce_flags & forbidden_flags) |
177 | 27.2k | && (ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) { |
178 | 9.53k | return 1; |
179 | 9.53k | } |
180 | 17.6k | break; |
181 | 27.2k | } |
182 | 17.6k | case ZEND_QM_ASSIGN: |
183 | 444 | if (opline->op1_type == IS_CONST |
184 | 444 | && Z_TYPE_P(CRT_CONSTANT(opline->op1)) == IS_ARRAY) { |
185 | 96 | return 1; |
186 | 96 | } |
187 | 348 | if (opline->op1_type == IS_CV && (OP1_INFO() & MAY_BE_ARRAY)) { |
188 | 176 | return 1; |
189 | 176 | } |
190 | 172 | break; |
191 | 531 | case ZEND_ASSIGN: |
192 | 531 | if (opline->op1_type == IS_CV && (OP1_INFO() & MAY_BE_ARRAY)) { |
193 | 198 | return 1; |
194 | 198 | } |
195 | 333 | break; |
196 | 195k | } |
197 | 195k | } else if (ssa_op->op1_def == var) { |
198 | 57.9k | switch (opline->opcode) { |
199 | 36.1k | case ZEND_ASSIGN: |
200 | 36.1k | if (opline->op2_type == IS_CONST |
201 | 36.1k | && Z_TYPE_P(CRT_CONSTANT(opline->op2)) == IS_ARRAY) { |
202 | 5.84k | return 1; |
203 | 5.84k | } |
204 | 30.2k | if (opline->op2_type == IS_CV && (OP2_INFO() & MAY_BE_ARRAY)) { |
205 | 420 | return 1; |
206 | 420 | } |
207 | 29.8k | break; |
208 | 29.8k | case ZEND_ASSIGN_DIM: |
209 | 1.98k | if (OP1_INFO() & (MAY_BE_UNDEF | MAY_BE_NULL | MAY_BE_FALSE)) { |
210 | | /* implicit object/array allocation */ |
211 | 1.88k | return 1; |
212 | 1.88k | } |
213 | 96 | break; |
214 | 57.9k | } |
215 | 57.9k | } |
216 | | |
217 | 231k | return 0; |
218 | 255k | } |
219 | | /* }}} */ |
220 | | |
221 | | static bool is_local_def(zend_op_array *op_array, zend_ssa *ssa, int def, int var, const zend_script *script) /* {{{ */ |
222 | 112k | { |
223 | 112k | zend_ssa_op *op = ssa->ops + def; |
224 | 112k | zend_op *opline = op_array->opcodes + def; |
225 | | |
226 | 112k | if (op->result_def == var) { |
227 | 87.0k | switch (opline->opcode) { |
228 | 3.71k | case ZEND_INIT_ARRAY: |
229 | 21.0k | case ZEND_ADD_ARRAY_ELEMENT: |
230 | 21.2k | case ZEND_QM_ASSIGN: |
231 | 21.6k | case ZEND_ASSIGN: |
232 | 21.6k | return 1; |
233 | 8.50k | case ZEND_NEW: { |
234 | | /* objects with destructors should escape */ |
235 | 8.50k | zend_class_entry *ce = zend_optimizer_get_class_entry_from_op1( |
236 | 8.50k | script, op_array, opline); |
237 | 8.50k | if (ce |
238 | 8.50k | && !ce->create_object |
239 | 8.50k | && ce->default_object_handlers->get_constructor == zend_std_get_constructor |
240 | 8.50k | && ce->default_object_handlers->dtor_obj == zend_objects_destroy_object |
241 | 8.50k | && !ce->constructor |
242 | 8.50k | && !ce->destructor |
243 | 8.50k | && !ce->__get |
244 | 8.50k | && !ce->__set |
245 | 8.50k | && !ce->parent) { |
246 | 5.73k | return 1; |
247 | 5.73k | } |
248 | 2.77k | break; |
249 | 8.50k | } |
250 | 87.0k | } |
251 | 87.0k | } else if (op->op1_def == var) { |
252 | 23.7k | switch (opline->opcode) { |
253 | 12.3k | case ZEND_ASSIGN: |
254 | 15.4k | case ZEND_ASSIGN_DIM: |
255 | 17.0k | case ZEND_ASSIGN_OBJ: |
256 | 17.0k | case ZEND_ASSIGN_OBJ_REF: |
257 | 17.1k | case ZEND_ASSIGN_DIM_OP: |
258 | 17.3k | case ZEND_ASSIGN_OBJ_OP: |
259 | 17.3k | case ZEND_PRE_INC_OBJ: |
260 | 17.4k | case ZEND_PRE_DEC_OBJ: |
261 | 17.4k | case ZEND_POST_INC_OBJ: |
262 | 17.5k | case ZEND_POST_DEC_OBJ: |
263 | 17.5k | return 1; |
264 | 23.7k | } |
265 | 23.7k | } |
266 | | |
267 | 67.7k | return 0; |
268 | 112k | } |
269 | | /* }}} */ |
270 | | |
271 | | static bool is_escape_use(zend_op_array *op_array, zend_ssa *ssa, int use, int var) /* {{{ */ |
272 | 21.2k | { |
273 | 21.2k | zend_ssa_op *ssa_op = ssa->ops + use; |
274 | 21.2k | zend_op *opline = op_array->opcodes + use; |
275 | | |
276 | 21.2k | if (ssa_op->op1_use == var) { |
277 | 11.4k | switch (opline->opcode) { |
278 | 568 | case ZEND_ASSIGN: |
279 | | /* no_val */ |
280 | 568 | break; |
281 | 142 | case ZEND_QM_ASSIGN: |
282 | 142 | if (opline->op1_type == IS_CV) { |
283 | 142 | if (OP1_INFO() & MAY_BE_OBJECT) { |
284 | | /* object aliasing */ |
285 | 128 | return 1; |
286 | 128 | } |
287 | 142 | } |
288 | 14 | break; |
289 | 58 | case ZEND_ISSET_ISEMPTY_DIM_OBJ: |
290 | 86 | case ZEND_ISSET_ISEMPTY_PROP_OBJ: |
291 | 1.24k | case ZEND_FETCH_DIM_R: |
292 | 1.41k | case ZEND_FETCH_OBJ_R: |
293 | 1.74k | case ZEND_FETCH_DIM_IS: |
294 | 1.75k | case ZEND_FETCH_OBJ_IS: |
295 | 1.75k | break; |
296 | 2 | case ZEND_ASSIGN_OP: |
297 | 2 | return 1; |
298 | 57 | case ZEND_ASSIGN_DIM_OP: |
299 | 151 | case ZEND_ASSIGN_OBJ_OP: |
300 | 151 | case ZEND_ASSIGN_STATIC_PROP_OP: |
301 | 2.82k | case ZEND_ASSIGN_DIM: |
302 | 3.29k | case ZEND_ASSIGN_OBJ: |
303 | 3.32k | case ZEND_ASSIGN_OBJ_REF: |
304 | 3.32k | break; |
305 | 0 | case ZEND_PRE_INC_OBJ: |
306 | 8 | case ZEND_PRE_DEC_OBJ: |
307 | 8 | case ZEND_POST_INC_OBJ: |
308 | 8 | case ZEND_POST_DEC_OBJ: |
309 | 8 | break; |
310 | 506 | case ZEND_INIT_ARRAY: |
311 | 1.22k | case ZEND_ADD_ARRAY_ELEMENT: |
312 | 1.22k | if (opline->extended_value & ZEND_ARRAY_ELEMENT_REF) { |
313 | 0 | return 1; |
314 | 0 | } |
315 | 1.22k | if (OP1_INFO() & MAY_BE_OBJECT) { |
316 | | /* object aliasing */ |
317 | 599 | return 1; |
318 | 599 | } |
319 | | /* reference dependencies processed separately */ |
320 | 627 | break; |
321 | 627 | case ZEND_OP_DATA: |
322 | 622 | if ((opline-1)->opcode != ZEND_ASSIGN_DIM |
323 | 622 | && (opline-1)->opcode != ZEND_ASSIGN_OBJ) { |
324 | 76 | return 1; |
325 | 76 | } |
326 | 546 | if (OP1_INFO() & MAY_BE_OBJECT) { |
327 | | /* object aliasing */ |
328 | 395 | return 1; |
329 | 395 | } |
330 | 151 | opline--; |
331 | 151 | ssa_op--; |
332 | 151 | if (opline->op1_type != IS_CV |
333 | 151 | || (OP1_INFO() & MAY_BE_REF) |
334 | 151 | || (ssa_op->op1_def >= 0 && ssa->vars[ssa_op->op1_def].alias)) { |
335 | | /* assignment into escaping structure */ |
336 | 99 | return 1; |
337 | 99 | } |
338 | | /* reference dependencies processed separately */ |
339 | 52 | break; |
340 | 3.84k | default: |
341 | 3.84k | return 1; |
342 | 11.4k | } |
343 | 11.4k | } |
344 | | |
345 | 16.0k | if (ssa_op->op2_use == var) { |
346 | 4.10k | switch (opline->opcode) { |
347 | 3.64k | case ZEND_ASSIGN: |
348 | 3.64k | if (opline->op1_type != IS_CV |
349 | 3.64k | || (OP1_INFO() & MAY_BE_REF) |
350 | 3.64k | || (ssa_op->op1_def >= 0 && ssa->vars[ssa_op->op1_def].alias)) { |
351 | | /* assignment into escaping variable */ |
352 | 2.74k | return 1; |
353 | 2.74k | } |
354 | 900 | if (opline->op2_type == IS_CV || opline->result_type != IS_UNUSED) { |
355 | 132 | if (OP2_INFO() & MAY_BE_OBJECT) { |
356 | | /* object aliasing */ |
357 | 76 | return 1; |
358 | 76 | } |
359 | 132 | } |
360 | 824 | break; |
361 | 824 | default: |
362 | 457 | return 1; |
363 | 4.10k | } |
364 | 4.10k | } |
365 | | |
366 | 12.8k | if (ssa_op->result_use == var) { |
367 | 5.65k | switch (opline->opcode) { |
368 | 0 | case ZEND_ASSIGN: |
369 | 0 | case ZEND_QM_ASSIGN: |
370 | 0 | case ZEND_INIT_ARRAY: |
371 | 5.65k | case ZEND_ADD_ARRAY_ELEMENT: |
372 | 5.65k | break; |
373 | 0 | default: |
374 | 0 | return 1; |
375 | 5.65k | } |
376 | 5.65k | } |
377 | | |
378 | 12.8k | return 0; |
379 | 12.8k | } |
380 | | /* }}} */ |
381 | | |
382 | | zend_result zend_ssa_escape_analysis(const zend_script *script, zend_op_array *op_array, zend_ssa *ssa) /* {{{ */ |
383 | 74.1k | { |
384 | 74.1k | zend_ssa_var *ssa_vars = ssa->vars; |
385 | 74.1k | int ssa_vars_count = ssa->vars_count; |
386 | 74.1k | int i, root, use; |
387 | 74.1k | int *ees; |
388 | 74.1k | bool has_allocations; |
389 | 74.1k | int num_non_escaped; |
390 | 74.1k | ALLOCA_FLAG(use_heap) |
391 | | |
392 | 74.1k | if (!ssa_vars) { |
393 | 0 | return SUCCESS; |
394 | 0 | } |
395 | | |
396 | 74.1k | has_allocations = 0; |
397 | 818k | for (i = op_array->last_var; i < ssa_vars_count; i++) { |
398 | 753k | if (ssa_vars[i].definition >= 0 |
399 | 753k | && (ssa->var_info[i].type & (MAY_BE_ARRAY|MAY_BE_OBJECT)) |
400 | 753k | && is_allocation_def(op_array, ssa, ssa_vars[i].definition, i, script)) { |
401 | 9.80k | has_allocations = 1; |
402 | 9.80k | break; |
403 | 9.80k | } |
404 | 753k | } |
405 | 74.1k | if (!has_allocations) { |
406 | 64.3k | return SUCCESS; |
407 | 64.3k | } |
408 | | |
409 | | |
410 | | /* 1. Build EES (Equi-Escape Sets) */ |
411 | 9.80k | ees = do_alloca(sizeof(int) * ssa_vars_count, use_heap); |
412 | 9.80k | if (!ees) { |
413 | 0 | return FAILURE; |
414 | 0 | } |
415 | | |
416 | 9.80k | if (zend_build_equi_escape_sets(ees, op_array, ssa) == FAILURE) { |
417 | 0 | free_alloca(ees, use_heap); |
418 | 0 | return FAILURE; |
419 | 0 | } |
420 | | |
421 | | /* 2. Identify Allocations */ |
422 | 9.80k | num_non_escaped = 0; |
423 | 399k | for (i = op_array->last_var; i < ssa_vars_count; i++) { |
424 | 390k | root = ees[i]; |
425 | 390k | if (ssa_vars[root].escape_state > ESCAPE_STATE_NO_ESCAPE) { |
426 | | /* already escape. skip */ |
427 | 344k | } else if (ssa_vars[i].alias && (ssa->var_info[i].type & MAY_BE_REF)) { |
428 | 0 | if (ssa_vars[root].escape_state == ESCAPE_STATE_NO_ESCAPE) { |
429 | 0 | num_non_escaped--; |
430 | 0 | } |
431 | 0 | ssa_vars[root].escape_state = ESCAPE_STATE_GLOBAL_ESCAPE; |
432 | 344k | } else if (ssa_vars[i].definition >= 0 |
433 | 344k | && (ssa->var_info[i].type & (MAY_BE_ARRAY|MAY_BE_OBJECT))) { |
434 | 112k | if (!is_local_def(op_array, ssa, ssa_vars[i].definition, i, script)) { |
435 | 67.7k | if (ssa_vars[root].escape_state == ESCAPE_STATE_NO_ESCAPE) { |
436 | 3.17k | num_non_escaped--; |
437 | 3.17k | } |
438 | 67.7k | ssa_vars[root].escape_state = ESCAPE_STATE_GLOBAL_ESCAPE; |
439 | 67.7k | } else if (ssa_vars[root].escape_state == ESCAPE_STATE_UNKNOWN |
440 | 44.9k | && is_allocation_def(op_array, ssa, ssa_vars[i].definition, i, script)) { |
441 | 13.9k | ssa_vars[root].escape_state = ESCAPE_STATE_NO_ESCAPE; |
442 | 13.9k | num_non_escaped++; |
443 | 13.9k | } |
444 | 112k | } |
445 | 390k | } |
446 | | |
447 | | /* 3. Mark escaped EES */ |
448 | 9.80k | if (num_non_escaped) { |
449 | 294k | for (i = 0; i < ssa_vars_count; i++) { |
450 | 287k | if (ssa_vars[i].use_chain >= 0) { |
451 | 236k | root = ees[i]; |
452 | 236k | if (ssa_vars[root].escape_state == ESCAPE_STATE_NO_ESCAPE) { |
453 | 40.9k | FOREACH_USE(ssa_vars + i, use) { |
454 | 40.9k | if (is_escape_use(op_array, ssa, use, i)) { |
455 | 8.42k | ssa_vars[root].escape_state = ESCAPE_STATE_GLOBAL_ESCAPE; |
456 | 8.42k | num_non_escaped--; |
457 | 8.42k | if (num_non_escaped == 0) { |
458 | 5.50k | i = ssa_vars_count; |
459 | 5.50k | } |
460 | 8.42k | break; |
461 | 8.42k | } |
462 | 40.9k | } FOREACH_USE_END(); |
463 | 19.6k | } |
464 | 236k | } |
465 | 287k | } |
466 | 6.98k | } |
467 | | |
468 | | /* 4. Process referential dependencies */ |
469 | 9.80k | if (num_non_escaped) { |
470 | 1.48k | bool changed; |
471 | | |
472 | 1.52k | do { |
473 | 1.52k | changed = 0; |
474 | 79.1k | for (i = 0; i < ssa_vars_count; i++) { |
475 | 77.5k | if (ssa_vars[i].use_chain >= 0) { |
476 | 61.9k | root = ees[i]; |
477 | 61.9k | if (ssa_vars[root].escape_state == ESCAPE_STATE_NO_ESCAPE) { |
478 | 15.6k | FOREACH_USE(ssa_vars + i, use) { |
479 | 15.6k | zend_ssa_op *op = ssa->ops + use; |
480 | 15.6k | zend_op *opline = op_array->opcodes + use; |
481 | 15.6k | int enclosing_root; |
482 | | |
483 | 15.6k | if (opline->opcode == ZEND_OP_DATA && |
484 | 8.44k | ((opline-1)->opcode == ZEND_ASSIGN_DIM || |
485 | 48 | (opline-1)->opcode == ZEND_ASSIGN_OBJ || |
486 | 48 | (opline-1)->opcode == ZEND_ASSIGN_OBJ_REF) && |
487 | 8.44k | op->op1_use == i && |
488 | 8.44k | (op-1)->op1_use >= 0) { |
489 | 48 | enclosing_root = ees[(op-1)->op1_use]; |
490 | 8.39k | } else if ((opline->opcode == ZEND_INIT_ARRAY || |
491 | 8.39k | opline->opcode == ZEND_ADD_ARRAY_ELEMENT) && |
492 | 8.39k | op->op1_use == i && |
493 | 8.39k | op->result_def >= 0) { |
494 | 1.30k | enclosing_root = ees[op->result_def]; |
495 | 7.08k | } else { |
496 | 7.08k | continue; |
497 | 7.08k | } |
498 | | |
499 | 1.35k | if (ssa_vars[enclosing_root].escape_state == ESCAPE_STATE_UNKNOWN || |
500 | 1.35k | ssa_vars[enclosing_root].escape_state > ssa_vars[root].escape_state) { |
501 | 625 | if (ssa_vars[enclosing_root].escape_state == ESCAPE_STATE_UNKNOWN) { |
502 | 2 | ssa_vars[root].escape_state = ESCAPE_STATE_GLOBAL_ESCAPE; |
503 | 623 | } else { |
504 | 623 | ssa_vars[root].escape_state = ssa_vars[enclosing_root].escape_state; |
505 | 623 | } |
506 | 625 | if (ssa_vars[root].escape_state == ESCAPE_STATE_GLOBAL_ESCAPE) { |
507 | 625 | num_non_escaped--; |
508 | 625 | if (num_non_escaped == 0) { |
509 | 131 | changed = 0; |
510 | 494 | } else { |
511 | 494 | changed = 1; |
512 | 494 | } |
513 | 625 | break; |
514 | 625 | } else { |
515 | 0 | changed = 1; |
516 | 0 | } |
517 | 625 | } |
518 | 1.35k | } FOREACH_USE_END(); |
519 | 7.25k | } |
520 | 61.9k | } |
521 | 77.5k | } |
522 | 1.52k | } while (changed); |
523 | 1.48k | } |
524 | | |
525 | | /* 5. Propagate values of escape sets to variables */ |
526 | 429k | for (i = 0; i < ssa_vars_count; i++) { |
527 | 419k | root = ees[i]; |
528 | 419k | if (i != root) { |
529 | 171k | ssa_vars[i].escape_state = ssa_vars[root].escape_state; |
530 | 171k | } |
531 | 419k | } |
532 | | |
533 | 9.80k | free_alloca(ees, use_heap); |
534 | | |
535 | 9.80k | return SUCCESS; |
536 | 9.80k | } |
537 | | /* }}} */ |