php-internal-docs 8.4.8
Unofficial docs for php/php-src
Loading...
Searching...
No Matches
block_pass.c
Go to the documentation of this file.
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#include "Optimizer/zend_optimizer.h"
23#include "Optimizer/zend_optimizer_internal.h"
24#include "zend_API.h"
25#include "zend_constants.h"
26#include "zend_execute.h"
27#include "zend_vm.h"
28#include "zend_bitset.h"
29#include "zend_cfg.h"
30#include "zend_dump.h"
31
32/* Checks if a constant (like "true") may be replaced by its value */
33bool zend_optimizer_get_persistent_constant(zend_string *name, zval *result, int copy)
34{
35 zend_constant *c = zend_hash_find_ptr(EG(zend_constants), name);
36 if (c) {
37 if ((ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT)
38 && !(ZEND_CONSTANT_FLAGS(c) & CONST_DEPRECATED)
39 && (!(ZEND_CONSTANT_FLAGS(c) & CONST_NO_FILE_CACHE)
40 || !(CG(compiler_options) & ZEND_COMPILE_WITH_FILE_CACHE))) {
41 ZVAL_COPY_VALUE(result, &c->value);
42 if (copy) {
43 Z_TRY_ADDREF_P(result);
44 }
45 return 1;
46 } else {
47 return 0;
48 }
49 }
50
51 /* Special constants null/true/false can always be substituted. */
52 c = zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name));
53 if (c) {
54 ZVAL_COPY_VALUE(result, &c->value);
55 return 1;
56 }
57 return 0;
58}
59
60/* Data dependencies macros */
61
62#define VAR_SOURCE(op) Tsource[VAR_NUM(op.var)]
63#define SET_VAR_SOURCE(opline) Tsource[VAR_NUM(opline->result.var)] = opline
64
65static void strip_leading_nops(zend_op_array *op_array, zend_basic_block *b)
66{
67 zend_op *opcodes = op_array->opcodes;
68
69 do {
70 b->start++;
71 b->len--;
72 } while (b->len > 0 && opcodes[b->start].opcode == ZEND_NOP);
73}
74
75static void strip_nops(zend_op_array *op_array, zend_basic_block *b)
76{
77 uint32_t i, j;
78
79 if (b->len == 0) {
80 return;
81 }
82
83 if (op_array->opcodes[b->start].opcode == ZEND_NOP) {
84 strip_leading_nops(op_array, b);
85 }
86
87 if (b->len == 0) {
88 return;
89 }
90
91 /* strip the inside NOPs */
92 i = j = b->start + 1;
93 while (i < b->start + b->len) {
94 if (op_array->opcodes[i].opcode != ZEND_NOP) {
95 if (i != j) {
96 op_array->opcodes[j] = op_array->opcodes[i];
97 }
98 j++;
99 }
100 i++;
101 }
102 b->len = j - b->start;
103 while (j < i) {
104 MAKE_NOP(op_array->opcodes + j);
105 j++;
106 }
107}
108
109static int get_const_switch_target(zend_cfg *cfg, zend_op_array *op_array, zend_basic_block *block, zend_op *opline, zval *val) {
110 HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
111 zval *zv;
112 if ((opline->opcode == ZEND_SWITCH_LONG && Z_TYPE_P(val) != IS_LONG)
113 || (opline->opcode == ZEND_SWITCH_STRING && Z_TYPE_P(val) != IS_STRING)) {
114 /* fallback to next block */
115 return block->successors[block->successors_count - 1];
116 }
117 if (opline->opcode == ZEND_MATCH && Z_TYPE_P(val) != IS_LONG && Z_TYPE_P(val) != IS_STRING) {
118 /* always jump to the default arm */
119 return block->successors[block->successors_count - 1];
120 }
121 if (Z_TYPE_P(val) == IS_LONG) {
122 zv = zend_hash_index_find(jumptable, Z_LVAL_P(val));
123 } else {
124 ZEND_ASSERT(Z_TYPE_P(val) == IS_STRING);
125 zv = zend_hash_find(jumptable, Z_STR_P(val));
126 }
127 if (!zv) {
128 /* default */
129 return block->successors[block->successors_count - (opline->opcode == ZEND_MATCH ? 1 : 2)];
130 }
131 return cfg->map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))];
132}
133
134static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array, zend_bitset used_ext, zend_cfg *cfg, zend_op **Tsource, uint32_t *opt_count)
135{
136 zend_op *opline, *src;
137 zend_op *end, *last_op = NULL;
138
139 if (block->len == 0) {
140 return;
141 }
142
143 if (op_array->opcodes[block->start].opcode == ZEND_NOP) {
144 /* remove leading NOPs */
145 strip_leading_nops(op_array, block);
146 }
147
148 opline = op_array->opcodes + block->start;
149 end = opline + block->len;
150 while (opline < end) {
151 /* Constant Propagation: strip X = QM_ASSIGN(const) */
152 if (opline->op1_type == IS_TMP_VAR &&
153 opline->opcode != ZEND_FREE) {
154 src = VAR_SOURCE(opline->op1);
155 if (src &&
156 src->opcode == ZEND_QM_ASSIGN &&
157 src->op1_type == IS_CONST
158 ) {
159 znode_op op1 = opline->op1;
160 if (opline->opcode == ZEND_VERIFY_RETURN_TYPE) {
161 COPY_NODE(opline->result, opline->op1);
162 COPY_NODE(opline->op1, src->op1);
163 VAR_SOURCE(op1) = NULL;
164 MAKE_NOP(src);
165 ++(*opt_count);
166 } else {
167 zval c;
168 ZVAL_COPY(&c, &ZEND_OP1_LITERAL(src));
169 if (opline->opcode != ZEND_CASE
170 && opline->opcode != ZEND_CASE_STRICT
171 && opline->opcode != ZEND_FETCH_LIST_R
172 && opline->opcode != ZEND_SWITCH_LONG
173 && opline->opcode != ZEND_SWITCH_STRING
174 && opline->opcode != ZEND_MATCH
175 && opline->opcode != ZEND_MATCH_ERROR
176 && zend_optimizer_update_op1_const(op_array, opline, &c)) {
177 VAR_SOURCE(op1) = NULL;
178 if (opline->opcode != ZEND_JMP_NULL
179 && !zend_bitset_in(used_ext, VAR_NUM(src->result.var))) {
180 literal_dtor(&ZEND_OP1_LITERAL(src));
181 MAKE_NOP(src);
182 }
183 ++(*opt_count);
184 } else {
185 zval_ptr_dtor_nogc(&c);
186 }
187 }
188 }
189 }
190
191 /* Constant Propagation: strip X = QM_ASSIGN(const) */
192 if (opline->op2_type == IS_TMP_VAR) {
193 src = VAR_SOURCE(opline->op2);
194 if (src &&
195 src->opcode == ZEND_QM_ASSIGN &&
196 src->op1_type == IS_CONST) {
197
198 znode_op op2 = opline->op2;
199 zval c;
200
201 ZVAL_COPY(&c, &ZEND_OP1_LITERAL(src));
202 if (zend_optimizer_update_op2_const(op_array, opline, &c)) {
203 VAR_SOURCE(op2) = NULL;
204 if (!zend_bitset_in(used_ext, VAR_NUM(src->result.var))) {
205 literal_dtor(&ZEND_OP1_LITERAL(src));
206 MAKE_NOP(src);
207 }
208 ++(*opt_count);
209 } else {
210 zval_ptr_dtor_nogc(&c);
211 }
212 }
213 }
214
215 switch (opline->opcode) {
216 case ZEND_ECHO:
217 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
218 src = VAR_SOURCE(opline->op1);
219 if (src &&
220 src->opcode == ZEND_CAST &&
221 src->extended_value == IS_STRING) {
222 /* T = CAST(X, String), ECHO(T) => NOP, ECHO(X) */
223 VAR_SOURCE(opline->op1) = NULL;
224 COPY_NODE(opline->op1, src->op1);
225 MAKE_NOP(src);
226 ++(*opt_count);
227 }
228 } else if (opline->op1_type == IS_CONST &&
229 Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_DOUBLE) {
230 if (last_op == opline - 1) {
231 /* compress consecutive ECHO's.
232 * Float to string conversion may be affected by current
233 * locale setting.
234 */
235 size_t l, old_len;
236
237 if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
238 convert_to_string(&ZEND_OP1_LITERAL(opline));
239 }
240 if (Z_TYPE(ZEND_OP1_LITERAL(last_op)) != IS_STRING) {
241 convert_to_string(&ZEND_OP1_LITERAL(last_op));
242 }
243 old_len = Z_STRLEN(ZEND_OP1_LITERAL(last_op));
244 l = old_len + Z_STRLEN(ZEND_OP1_LITERAL(opline));
245 if (!Z_REFCOUNTED(ZEND_OP1_LITERAL(last_op))) {
246 zend_string *tmp = zend_string_alloc(l, 0);
247 memcpy(ZSTR_VAL(tmp), Z_STRVAL(ZEND_OP1_LITERAL(last_op)), old_len);
248 Z_STR(ZEND_OP1_LITERAL(last_op)) = tmp;
249 } else {
250 Z_STR(ZEND_OP1_LITERAL(last_op)) = zend_string_extend(Z_STR(ZEND_OP1_LITERAL(last_op)), l, 0);
251 }
252 Z_TYPE_INFO(ZEND_OP1_LITERAL(last_op)) = IS_STRING_EX;
253 memcpy(Z_STRVAL(ZEND_OP1_LITERAL(last_op)) + old_len, Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)));
254 Z_STRVAL(ZEND_OP1_LITERAL(last_op))[l] = '\0';
255 zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
256 ZVAL_STR(&ZEND_OP1_LITERAL(opline), zend_new_interned_string(Z_STR(ZEND_OP1_LITERAL(last_op))));
257 ZVAL_NULL(&ZEND_OP1_LITERAL(last_op));
258 MAKE_NOP(last_op);
259 ++(*opt_count);
260 }
261 last_op = opline;
262 }
263 break;
264
265 case ZEND_MATCH_ERROR:
266 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
267 src = VAR_SOURCE(opline->op1);
268 VAR_SOURCE(opline->op1) = NULL;
269 }
270 break;
271
272 case ZEND_FREE:
273 /* Note: Only remove the source if the source is local to this block.
274 * If it's not local, then the other blocks successors must also eventually either FREE or consume the temporary,
275 * hence removing the temporary is not safe in the general case, especially when other consumers are not FREE.
276 * A FREE may not be removed without also removing the source's result, because otherwise that would cause a memory leak. */
277 if (opline->op1_type == IS_TMP_VAR) {
278 src = VAR_SOURCE(opline->op1);
279 if (src) {
280 switch (src->opcode) {
281 case ZEND_BOOL:
282 case ZEND_BOOL_NOT:
283 /* T = BOOL(X), FREE(T) => T = BOOL(X) */
284 /* The remaining BOOL is removed by a separate optimization */
285 /* The source is a bool, no source removals take place, so this may be done non-locally. */
286 VAR_SOURCE(opline->op1) = NULL;
287 MAKE_NOP(opline);
288 ++(*opt_count);
289 break;
290 case ZEND_ASSIGN:
291 case ZEND_ASSIGN_DIM:
292 case ZEND_ASSIGN_OBJ:
293 case ZEND_ASSIGN_STATIC_PROP:
294 case ZEND_ASSIGN_OP:
295 case ZEND_ASSIGN_DIM_OP:
296 case ZEND_ASSIGN_OBJ_OP:
297 case ZEND_ASSIGN_STATIC_PROP_OP:
298 case ZEND_PRE_INC:
299 case ZEND_PRE_DEC:
300 case ZEND_PRE_INC_OBJ:
301 case ZEND_PRE_DEC_OBJ:
302 case ZEND_PRE_INC_STATIC_PROP:
303 case ZEND_PRE_DEC_STATIC_PROP:
304 if (src < op_array->opcodes + block->start) {
305 break;
306 }
307 src->result_type = IS_UNUSED;
308 VAR_SOURCE(opline->op1) = NULL;
309 MAKE_NOP(opline);
310 ++(*opt_count);
311 break;
312 default:
313 break;
314 }
315 }
316 } else if (opline->op1_type == IS_VAR) {
317 src = VAR_SOURCE(opline->op1);
318 /* V = OP, FREE(V) => OP. NOP */
319 if (src >= op_array->opcodes + block->start &&
320 src->opcode != ZEND_FETCH_R &&
321 src->opcode != ZEND_FETCH_STATIC_PROP_R &&
322 src->opcode != ZEND_FETCH_DIM_R &&
323 src->opcode != ZEND_FETCH_OBJ_R &&
324 src->opcode != ZEND_NEW &&
325 src->opcode != ZEND_FETCH_THIS) {
326 src->result_type = IS_UNUSED;
327 MAKE_NOP(opline);
328 ++(*opt_count);
329 if (src->opcode == ZEND_QM_ASSIGN) {
330 if (src->op1_type & (IS_VAR|IS_TMP_VAR)) {
331 src->opcode = ZEND_FREE;
332 } else {
333 MAKE_NOP(src);
334 }
335 }
336 }
337 }
338 break;
339
340#if 0
341 /* pre-evaluate functions:
342 constant(x)
343 function_exists(x)
344 extension_loaded(x)
345 BAD: interacts badly with Accelerator
346 */
347 if((opline->op1_type & IS_VAR) &&
348 VAR_SOURCE(opline->op1) && VAR_SOURCE(opline->op1)->opcode == ZEND_DO_CF_FCALL &&
349 VAR_SOURCE(opline->op1)->extended_value == 1) {
350 zend_op *fcall = VAR_SOURCE(opline->op1);
351 zend_op *sv = fcall-1;
352 if(sv >= block->start_opline && sv->opcode == ZEND_SEND_VAL &&
353 sv->op1_type == IS_CONST && Z_TYPE(OPLINE_OP1_LITERAL(sv)) == IS_STRING &&
354 Z_LVAL(OPLINE_OP2_LITERAL(sv)) == 1
355 ) {
356 zval *arg = &OPLINE_OP1_LITERAL(sv);
357 char *fname = FUNCTION_CACHE->funcs[Z_LVAL(ZEND_OP1_LITERAL(fcall))].function_name;
358 size_t flen = FUNCTION_CACHE->funcs[Z_LVAL(ZEND_OP1_LITERAL(fcall))].name_len;
359 if((flen == sizeof("function_exists")-1 && zend_binary_strcasecmp(fname, flen, "function_exists", sizeof("function_exists")-1) == 0) ||
360 (flen == sizeof("is_callable")-1 && zend_binary_strcasecmp(fname, flen, "is_callable", sizeof("is_callable")-1) == 0)
361 ) {
362 zend_function *function;
363 if((function = zend_hash_find_ptr(EG(function_table), Z_STR_P(arg))) != NULL) {
364 literal_dtor(arg);
365 MAKE_NOP(sv);
366 MAKE_NOP(fcall);
367 LITERAL_BOOL(opline->op1, 1);
368 opline->op1_type = IS_CONST;
369 }
370 } else if(flen == sizeof("constant")-1 && zend_binary_strcasecmp(fname, flen, "constant", sizeof("constant")-1) == 0) {
371 zval c;
372 if (zend_optimizer_get_persistent_constant(Z_STR_P(arg), &c, 1 ELS_CC)) {
373 literal_dtor(arg);
374 MAKE_NOP(sv);
375 MAKE_NOP(fcall);
376 ZEND_OP1_LITERAL(opline) = zend_optimizer_add_literal(op_array, &c);
377 /* no copy ctor - get already copied it */
378 opline->op1_type = IS_CONST;
379 }
380 } else if(flen == sizeof("extension_loaded")-1 && zend_binary_strcasecmp(fname, flen, "extension_loaded", sizeof("extension_loaded")-1) == 0) {
381 if(zend_hash_exists(&module_registry, Z_STR_P(arg))) {
382 literal_dtor(arg);
383 MAKE_NOP(sv);
384 MAKE_NOP(fcall);
385 LITERAL_BOOL(opline->op1, 1);
386 opline->op1_type = IS_CONST;
387 }
388 }
389 }
390 }
391#endif
392
393 case ZEND_FETCH_LIST_R:
394 case ZEND_FETCH_LIST_W:
395 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
396 /* LIST variable will be deleted later by FREE */
397 Tsource[VAR_NUM(opline->op1.var)] = NULL;
398 }
399 break;
400
401 case ZEND_SWITCH_LONG:
402 case ZEND_SWITCH_STRING:
403 case ZEND_MATCH:
404 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
405 /* SWITCH variable will be deleted later by FREE, so we can't optimize it */
406 Tsource[VAR_NUM(opline->op1.var)] = NULL;
407 break;
408 }
409 if (opline->op1_type == IS_CONST) {
410 int target = get_const_switch_target(cfg, op_array, block, opline, &ZEND_OP1_LITERAL(opline));
411 literal_dtor(&ZEND_OP1_LITERAL(opline));
412 literal_dtor(&ZEND_OP2_LITERAL(opline));
413 opline->opcode = ZEND_JMP;
414 opline->op1_type = IS_UNUSED;
415 opline->op2_type = IS_UNUSED;
416 block->successors_count = 1;
417 block->successors[0] = target;
418 }
419 break;
420
421 case ZEND_CASE:
422 case ZEND_CASE_STRICT:
423 case ZEND_COPY_TMP:
424 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
425 /* Variable will be deleted later by FREE, so we can't optimize it */
426 Tsource[VAR_NUM(opline->op1.var)] = NULL;
427 break;
428 }
429 ZEND_FALLTHROUGH;
430
431 case ZEND_IS_EQUAL:
432 case ZEND_IS_NOT_EQUAL:
433 if (opline->op1_type == IS_CONST &&
434 opline->op2_type == IS_CONST) {
435 goto optimize_constant_binary_op;
436 }
437 /* IS_EQ(TRUE, X) => BOOL(X)
438 * IS_EQ(FALSE, X) => BOOL_NOT(X)
439 * IS_NOT_EQ(TRUE, X) => BOOL_NOT(X)
440 * IS_NOT_EQ(FALSE, X) => BOOL(X)
441 * CASE(TRUE, X) => BOOL(X)
442 * CASE(FALSE, X) => BOOL_NOT(X)
443 */
444 if (opline->op1_type == IS_CONST &&
445 (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_FALSE ||
446 Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_TRUE)) {
447 /* Optimization of comparison with "null" is not safe,
448 * because ("0" == null) is not equal to !("0")
449 */
450 opline->opcode =
451 ((opline->opcode != ZEND_IS_NOT_EQUAL) == ((Z_TYPE(ZEND_OP1_LITERAL(opline))) == IS_TRUE)) ?
452 ZEND_BOOL : ZEND_BOOL_NOT;
453 COPY_NODE(opline->op1, opline->op2);
454 SET_UNUSED(opline->op2);
455 ++(*opt_count);
456 goto optimize_bool;
457 } else if (opline->op2_type == IS_CONST &&
458 (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_FALSE ||
459 Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_TRUE)) {
460 /* Optimization of comparison with "null" is not safe,
461 * because ("0" == null) is not equal to !("0")
462 */
463 opline->opcode =
464 ((opline->opcode != ZEND_IS_NOT_EQUAL) == ((Z_TYPE(ZEND_OP2_LITERAL(opline))) == IS_TRUE)) ?
465 ZEND_BOOL : ZEND_BOOL_NOT;
466 SET_UNUSED(opline->op2);
467 ++(*opt_count);
468 goto optimize_bool;
469 }
470 break;
471
472 case ZEND_BOOL:
473 case ZEND_BOOL_NOT:
474 optimize_bool:
475 if (opline->op1_type == IS_CONST) {
476 goto optimize_const_unary_op;
477 }
478 if (opline->op1_type == IS_TMP_VAR &&
479 !zend_bitset_in(used_ext, VAR_NUM(opline->op1.var))) {
480 src = VAR_SOURCE(opline->op1);
481 if (src) {
482 switch (src->opcode) {
483 case ZEND_BOOL_NOT:
484 /* T = BOOL_NOT(X) + BOOL(T) -> NOP, BOOL_NOT(X) */
485 VAR_SOURCE(opline->op1) = NULL;
486 COPY_NODE(opline->op1, src->op1);
487 opline->opcode = (opline->opcode == ZEND_BOOL) ? ZEND_BOOL_NOT : ZEND_BOOL;
488 MAKE_NOP(src);
489 ++(*opt_count);
490 goto optimize_bool;
491 case ZEND_BOOL:
492 /* T = BOOL(X) + BOOL(T) -> NOP, BOOL(X) */
493 VAR_SOURCE(opline->op1) = NULL;
494 COPY_NODE(opline->op1, src->op1);
495 MAKE_NOP(src);
496 ++(*opt_count);
497 goto optimize_bool;
498 case ZEND_IS_EQUAL:
499 if (opline->opcode == ZEND_BOOL_NOT) {
500 src->opcode = ZEND_IS_NOT_EQUAL;
501 }
502 COPY_NODE(src->result, opline->result);
503 SET_VAR_SOURCE(src);
504 MAKE_NOP(opline);
505 ++(*opt_count);
506 break;
507 case ZEND_IS_NOT_EQUAL:
508 if (opline->opcode == ZEND_BOOL_NOT) {
509 src->opcode = ZEND_IS_EQUAL;
510 }
511 COPY_NODE(src->result, opline->result);
512 SET_VAR_SOURCE(src);
513 MAKE_NOP(opline);
514 ++(*opt_count);
515 break;
516 case ZEND_IS_IDENTICAL:
517 if (opline->opcode == ZEND_BOOL_NOT) {
518 src->opcode = ZEND_IS_NOT_IDENTICAL;
519 }
520 COPY_NODE(src->result, opline->result);
521 SET_VAR_SOURCE(src);
522 MAKE_NOP(opline);
523 ++(*opt_count);
524 break;
525 case ZEND_IS_NOT_IDENTICAL:
526 if (opline->opcode == ZEND_BOOL_NOT) {
527 src->opcode = ZEND_IS_IDENTICAL;
528 }
529 COPY_NODE(src->result, opline->result);
530 SET_VAR_SOURCE(src);
531 MAKE_NOP(opline);
532 ++(*opt_count);
533 break;
534 case ZEND_IS_SMALLER:
535 if (opline->opcode == ZEND_BOOL_NOT) {
536 uint8_t tmp_type;
537 uint32_t tmp;
538
539 src->opcode = ZEND_IS_SMALLER_OR_EQUAL;
540 tmp_type = src->op1_type;
541 src->op1_type = src->op2_type;
542 src->op2_type = tmp_type;
543 tmp = src->op1.num;
544 src->op1.num = src->op2.num;
545 src->op2.num = tmp;
546 }
547 COPY_NODE(src->result, opline->result);
548 SET_VAR_SOURCE(src);
549 MAKE_NOP(opline);
550 ++(*opt_count);
551 break;
552 case ZEND_IS_SMALLER_OR_EQUAL:
553 if (opline->opcode == ZEND_BOOL_NOT) {
554 uint8_t tmp_type;
555 uint32_t tmp;
556
557 src->opcode = ZEND_IS_SMALLER;
558 tmp_type = src->op1_type;
559 src->op1_type = src->op2_type;
560 src->op2_type = tmp_type;
561 tmp = src->op1.num;
562 src->op1.num = src->op2.num;
563 src->op2.num = tmp;
564 }
565 COPY_NODE(src->result, opline->result);
566 SET_VAR_SOURCE(src);
567 MAKE_NOP(opline);
568 ++(*opt_count);
569 break;
570 case ZEND_ISSET_ISEMPTY_CV:
571 case ZEND_ISSET_ISEMPTY_VAR:
572 case ZEND_ISSET_ISEMPTY_DIM_OBJ:
573 case ZEND_ISSET_ISEMPTY_PROP_OBJ:
574 case ZEND_ISSET_ISEMPTY_STATIC_PROP:
575 case ZEND_INSTANCEOF:
576 case ZEND_TYPE_CHECK:
577 case ZEND_DEFINED:
578 case ZEND_IN_ARRAY:
579 case ZEND_ARRAY_KEY_EXISTS:
580 if (opline->opcode == ZEND_BOOL_NOT) {
581 break;
582 }
583 COPY_NODE(src->result, opline->result);
584 SET_VAR_SOURCE(src);
585 MAKE_NOP(opline);
586 ++(*opt_count);
587 break;
588 }
589 }
590 }
591 break;
592
593 case ZEND_JMPZ:
594 case ZEND_JMPNZ:
595 while (1) {
596 if (opline->op1_type == IS_CONST) {
597 ++(*opt_count);
598 block->successors_count = 1;
599 if (zend_is_true(&ZEND_OP1_LITERAL(opline)) ==
600 (opline->opcode == ZEND_JMPZ)) {
601
602 MAKE_NOP(opline);
603 block->successors[0] = block->successors[1];
604 block->len--;
605 cfg->blocks[block->successors[0]].flags |= ZEND_BB_FOLLOW;
606 break;
607 } else {
608 zend_basic_block *next = cfg->blocks + block->successors[1];
609
610 next->flags &= ~ZEND_BB_FOLLOW;
611 if (!(next->flags & (ZEND_BB_TARGET|ZEND_BB_PROTECTED))) {
612 next->flags &= ~ZEND_BB_REACHABLE;
613 }
614 opline->opcode = ZEND_JMP;
615 COPY_NODE(opline->op1, opline->op2);
616 break;
617 }
618 } else if (opline->op1_type == IS_TMP_VAR &&
619 !zend_bitset_in(used_ext, VAR_NUM(opline->op1.var))) {
620 src = VAR_SOURCE(opline->op1);
621 if (src) {
622 if (src->opcode == ZEND_BOOL_NOT) {
623 VAR_SOURCE(opline->op1) = NULL;
624 COPY_NODE(opline->op1, src->op1);
625 /* T = BOOL_NOT(X) + JMPZ(T) -> NOP, JMPNZ(X) */
626 opline->opcode = INV_COND(opline->opcode);
627 MAKE_NOP(src);
628 ++(*opt_count);
629 continue;
630 } else if (src->opcode == ZEND_BOOL ||
631 src->opcode == ZEND_QM_ASSIGN) {
632 VAR_SOURCE(opline->op1) = NULL;
633 COPY_NODE(opline->op1, src->op1);
634 MAKE_NOP(src);
635 ++(*opt_count);
636 continue;
637 }
638 }
639 }
640 break;
641 }
642 break;
643
644 case ZEND_JMPZ_EX:
645 case ZEND_JMPNZ_EX:
646 while (1) {
647 if (opline->op1_type == IS_CONST) {
648 bool is_jmpz_ex = opline->opcode == ZEND_JMPZ_EX;
649 if (zend_is_true(&ZEND_OP1_LITERAL(opline)) == is_jmpz_ex) {
650
651 ++(*opt_count);
652 opline->opcode = ZEND_QM_ASSIGN;
653 zval_ptr_dtor_nogc(&ZEND_OP1_LITERAL(opline));
654 ZVAL_BOOL(&ZEND_OP1_LITERAL(opline), is_jmpz_ex);
655 opline->op2.num = 0;
656 block->successors_count = 1;
657 block->successors[0] = block->successors[1];
658 cfg->blocks[block->successors[0]].flags |= ZEND_BB_FOLLOW;
659 break;
660 }
661 } else if (opline->op1_type == IS_TMP_VAR &&
662 (!zend_bitset_in(used_ext, VAR_NUM(opline->op1.var)) ||
663 opline->result.var == opline->op1.var)) {
664 src = VAR_SOURCE(opline->op1);
665 if (src) {
666 if (src->opcode == ZEND_BOOL ||
667 src->opcode == ZEND_QM_ASSIGN) {
668 VAR_SOURCE(opline->op1) = NULL;
669 COPY_NODE(opline->op1, src->op1);
670 MAKE_NOP(src);
671 ++(*opt_count);
672 continue;
673 }
674 }
675 }
676 break;
677 }
678 break;
679
680 case ZEND_CONCAT:
681 case ZEND_FAST_CONCAT:
682 if (opline->op1_type == IS_CONST &&
683 opline->op2_type == IS_CONST) {
684 goto optimize_constant_binary_op;
685 }
686
687 if (opline->op2_type == IS_CONST &&
688 opline->op1_type == IS_TMP_VAR) {
689
690 src = VAR_SOURCE(opline->op1);
691 if (src &&
692 (src->opcode == ZEND_CONCAT ||
693 src->opcode == ZEND_FAST_CONCAT) &&
694 src->op2_type == IS_CONST) {
695 /* compress consecutive CONCATs */
696 size_t l, old_len;
697
698 if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
699 convert_to_string(&ZEND_OP2_LITERAL(opline));
700 }
701 if (Z_TYPE(ZEND_OP2_LITERAL(src)) != IS_STRING) {
702 convert_to_string(&ZEND_OP2_LITERAL(src));
703 }
704
705 VAR_SOURCE(opline->op1) = NULL;
706 COPY_NODE(opline->op1, src->op1);
707 old_len = Z_STRLEN(ZEND_OP2_LITERAL(src));
708 l = old_len + Z_STRLEN(ZEND_OP2_LITERAL(opline));
709 if (!Z_REFCOUNTED(ZEND_OP2_LITERAL(src))) {
710 zend_string *tmp = zend_string_alloc(l, 0);
711 memcpy(ZSTR_VAL(tmp), Z_STRVAL(ZEND_OP2_LITERAL(src)), old_len);
712 Z_STR(ZEND_OP2_LITERAL(src)) = tmp;
713 } else {
714 Z_STR(ZEND_OP2_LITERAL(src)) = zend_string_extend(Z_STR(ZEND_OP2_LITERAL(src)), l, 0);
715 }
716 Z_TYPE_INFO(ZEND_OP2_LITERAL(src)) = IS_STRING_EX;
717 memcpy(Z_STRVAL(ZEND_OP2_LITERAL(src)) + old_len, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
718 Z_STRVAL(ZEND_OP2_LITERAL(src))[l] = '\0';
719 zval_ptr_dtor_str(&ZEND_OP2_LITERAL(opline));
720 ZVAL_STR(&ZEND_OP2_LITERAL(opline), zend_new_interned_string(Z_STR(ZEND_OP2_LITERAL(src))));
721 ZVAL_NULL(&ZEND_OP2_LITERAL(src));
722 MAKE_NOP(src);
723 ++(*opt_count);
724 }
725 }
726
727 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
728 src = VAR_SOURCE(opline->op1);
729 if (src &&
730 src->opcode == ZEND_CAST &&
731 src->extended_value == IS_STRING &&
732 src->op1_type != IS_CONST) {
733 /* convert T1 = CAST(STRING, X), T2 = CONCAT(T1, Y) to T2 = CONCAT(X,Y) */
734 VAR_SOURCE(opline->op1) = NULL;
735 COPY_NODE(opline->op1, src->op1);
736 MAKE_NOP(src);
737 ++(*opt_count);
738 }
739 }
740 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
741 src = VAR_SOURCE(opline->op2);
742 if (src &&
743 src->opcode == ZEND_CAST &&
744 src->extended_value == IS_STRING &&
745 src->op1_type != IS_CONST) {
746 /* convert T1 = CAST(STRING, X), T2 = CONCAT(Y, T1) to T2 = CONCAT(Y,X) */
747 zend_op *src = VAR_SOURCE(opline->op2);
748 VAR_SOURCE(opline->op2) = NULL;
749 COPY_NODE(opline->op2, src->op1);
750 MAKE_NOP(src);
751 ++(*opt_count);
752 }
753 }
754 if (opline->op1_type == IS_CONST &&
755 Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
756 Z_STRLEN(ZEND_OP1_LITERAL(opline)) == 0) {
757 /* convert CONCAT('', X) => CAST(STRING, X) */
758 literal_dtor(&ZEND_OP1_LITERAL(opline));
759 opline->opcode = ZEND_CAST;
760 opline->extended_value = IS_STRING;
761 COPY_NODE(opline->op1, opline->op2);
762 opline->op2_type = IS_UNUSED;
763 opline->op2.var = 0;
764 ++(*opt_count);
765 } else if (opline->op2_type == IS_CONST &&
766 Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
767 Z_STRLEN(ZEND_OP2_LITERAL(opline)) == 0) {
768 /* convert CONCAT(X, '') => CAST(STRING, X) */
769 literal_dtor(&ZEND_OP2_LITERAL(opline));
770 opline->opcode = ZEND_CAST;
771 opline->extended_value = IS_STRING;
772 opline->op2_type = IS_UNUSED;
773 opline->op2.var = 0;
774 ++(*opt_count);
775 } else if (opline->opcode == ZEND_CONCAT &&
776 (opline->op1_type == IS_CONST ||
777 (opline->op1_type == IS_TMP_VAR &&
778 VAR_SOURCE(opline->op1) &&
779 (VAR_SOURCE(opline->op1)->opcode == ZEND_FAST_CONCAT ||
780 VAR_SOURCE(opline->op1)->opcode == ZEND_ROPE_END ||
781 VAR_SOURCE(opline->op1)->opcode == ZEND_FETCH_CONSTANT ||
782 VAR_SOURCE(opline->op1)->opcode == ZEND_FETCH_CLASS_CONSTANT))) &&
783 (opline->op2_type == IS_CONST ||
784 (opline->op2_type == IS_TMP_VAR &&
785 VAR_SOURCE(opline->op2) &&
786 (VAR_SOURCE(opline->op2)->opcode == ZEND_FAST_CONCAT ||
787 VAR_SOURCE(opline->op2)->opcode == ZEND_ROPE_END ||
788 VAR_SOURCE(opline->op2)->opcode == ZEND_FETCH_CONSTANT ||
789 VAR_SOURCE(opline->op2)->opcode == ZEND_FETCH_CLASS_CONSTANT)))) {
790 opline->opcode = ZEND_FAST_CONCAT;
791 ++(*opt_count);
792 }
793 break;
794
795 case ZEND_ADD:
796 case ZEND_SUB:
797 case ZEND_MUL:
798 case ZEND_DIV:
799 case ZEND_MOD:
800 case ZEND_SL:
801 case ZEND_SR:
802 case ZEND_IS_SMALLER:
803 case ZEND_IS_SMALLER_OR_EQUAL:
804 case ZEND_IS_IDENTICAL:
805 case ZEND_IS_NOT_IDENTICAL:
806 case ZEND_BOOL_XOR:
807 case ZEND_BW_OR:
808 case ZEND_BW_AND:
809 case ZEND_BW_XOR:
810 if (opline->op1_type == IS_CONST &&
811 opline->op2_type == IS_CONST) {
812 /* evaluate constant expressions */
813 zval result;
814
815optimize_constant_binary_op:
816 if (zend_optimizer_eval_binary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline)) == SUCCESS) {
817 literal_dtor(&ZEND_OP1_LITERAL(opline));
818 literal_dtor(&ZEND_OP2_LITERAL(opline));
819 opline->opcode = ZEND_QM_ASSIGN;
820 SET_UNUSED(opline->op2);
821 zend_optimizer_update_op1_const(op_array, opline, &result);
822 ++(*opt_count);
823 }
824 }
825 break;
826
827 case ZEND_BW_NOT:
828 if (opline->op1_type == IS_CONST) {
829 /* evaluate constant unary ops */
830 zval result;
831
832optimize_const_unary_op:
833 if (zend_optimizer_eval_unary_op(&result, opline->opcode, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
834 literal_dtor(&ZEND_OP1_LITERAL(opline));
835 opline->opcode = ZEND_QM_ASSIGN;
836 zend_optimizer_update_op1_const(op_array, opline, &result);
837 ++(*opt_count);
838 }
839 }
840 break;
841
842 case ZEND_CAST:
843 if (opline->op1_type == IS_CONST) {
844 /* cast of constant operand */
845 zval result;
846
847 if (zend_optimizer_eval_cast(&result, opline->extended_value, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
848 literal_dtor(&ZEND_OP1_LITERAL(opline));
849 opline->opcode = ZEND_QM_ASSIGN;
850 opline->extended_value = 0;
851 zend_optimizer_update_op1_const(op_array, opline, &result);
852 ++(*opt_count);
853 }
854 }
855 break;
856
857 case ZEND_STRLEN:
858 if (opline->op1_type == IS_CONST) {
859 zval result;
860
861 if (zend_optimizer_eval_strlen(&result, &ZEND_OP1_LITERAL(opline)) == SUCCESS) {
862 literal_dtor(&ZEND_OP1_LITERAL(opline));
863 opline->opcode = ZEND_QM_ASSIGN;
864 zend_optimizer_update_op1_const(op_array, opline, &result);
865 ++(*opt_count);
866 }
867 }
868 break;
869
870 case ZEND_RETURN:
871 if (opline->op1_type == IS_TMP_VAR) {
872 src = VAR_SOURCE(opline->op1);
873 if (src && src->opcode == ZEND_QM_ASSIGN) {
874 zend_op *op = src + 1;
875 bool optimize = 1;
876
877 while (op < opline) {
878 if ((op->op1_type == opline->op1_type
879 && op->op1.var == opline->op1.var)
880 || (op->op2_type == opline->op1_type
881 && op->op2.var == opline->op1.var)) {
882 optimize = 0;
883 break;
884 }
885 op++;
886 }
887
888 if (optimize) {
889 /* T = QM_ASSIGN(X), RETURN(T) to NOP, RETURN(X) */
890 VAR_SOURCE(opline->op1) = NULL;
891 COPY_NODE(opline->op1, src->op1);
892 MAKE_NOP(src);
893 ++(*opt_count);
894 }
895 }
896 }
897 break;
898
899 case ZEND_QM_ASSIGN:
900 if (opline->op1_type == opline->result_type &&
901 opline->op1.var == opline->result.var) {
902 /* strip T = QM_ASSIGN(T) */
903 MAKE_NOP(opline);
904 ++(*opt_count);
905 } else if (opline->op1_type == IS_TMP_VAR &&
906 opline->result_type == IS_TMP_VAR &&
907 !zend_bitset_in(used_ext, VAR_NUM(opline->op1.var))) {
908 /* T1 = ..., T2 = QM_ASSIGN(T1) to T2 = ..., NOP */
909 src = VAR_SOURCE(opline->op1);
910 if (src &&
911 src->opcode != ZEND_COPY_TMP &&
912 src->opcode != ZEND_ADD_ARRAY_ELEMENT &&
913 src->opcode != ZEND_ADD_ARRAY_UNPACK &&
914 (src->opcode != ZEND_DECLARE_LAMBDA_FUNCTION ||
915 src == opline -1)) {
916 src->result.var = opline->result.var;
917 VAR_SOURCE(opline->op1) = NULL;
918 VAR_SOURCE(opline->result) = src;
919 MAKE_NOP(opline);
920 ++(*opt_count);
921 }
922 }
923 break;
924 }
925
926 /* get variable source */
927 if (opline->result_type & (IS_VAR|IS_TMP_VAR)) {
928 SET_VAR_SOURCE(opline);
929 }
930 opline++;
931 }
932}
933
934/* Rebuild plain (optimized) op_array from CFG */
935static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_optimizer_ctx *ctx)
936{
937 zend_basic_block *blocks = cfg->blocks;
938 zend_basic_block *end = blocks + cfg->blocks_count;
939 zend_basic_block *b;
940 zend_op *new_opcodes;
941 zend_op *opline;
942 uint32_t len = 0;
943
944 for (b = blocks; b < end; b++) {
945 if (b->len == 0) {
946 continue;
947 }
948 if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
949 opline = op_array->opcodes + b->start + b->len - 1;
950 if (opline->opcode == ZEND_JMP) {
951 zend_basic_block *next = b + 1;
952
953 while (next < end && !(next->flags & ZEND_BB_REACHABLE)) {
954 next++;
955 }
956 if (next < end && next == blocks + b->successors[0]) {
957 /* JMP to the next block - strip it */
958 MAKE_NOP(opline);
959 b->len--;
960 }
961 } else if (b->len == 1 && opline->opcode == ZEND_NOP) {
962 /* skip empty block */
963 b->len--;
964 }
965 len += b->len;
966 } else {
967 /* this block will not be used, delete all constants there */
968 zend_op *op = op_array->opcodes + b->start;
969 zend_op *end = op + b->len;
970 for (; op < end; op++) {
971 if (op->op1_type == IS_CONST) {
972 literal_dtor(&ZEND_OP1_LITERAL(op));
973 }
974 if (op->op2_type == IS_CONST) {
975 literal_dtor(&ZEND_OP2_LITERAL(op));
976 }
977 }
978 }
979 }
980
981 new_opcodes = emalloc(len * sizeof(zend_op));
982 opline = new_opcodes;
983
984 /* Copy code of reachable blocks into a single buffer */
985 for (b = blocks; b < end; b++) {
986 if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
987 memcpy(opline, op_array->opcodes + b->start, b->len * sizeof(zend_op));
988 b->start = opline - new_opcodes;
989 opline += b->len;
990 }
991 }
992
993 /* adjust jump targets */
994 efree(op_array->opcodes);
995 op_array->opcodes = new_opcodes;
996 op_array->last = len;
997
998 for (b = blocks; b < end; b++) {
999 if (!(b->flags & ZEND_BB_REACHABLE) || b->len == 0) {
1000 continue;
1001 }
1002 opline = op_array->opcodes + b->start + b->len - 1;
1003 switch (opline->opcode) {
1004 case ZEND_FAST_CALL:
1005 case ZEND_JMP:
1006 ZEND_SET_OP_JMP_ADDR(opline, opline->op1, new_opcodes + blocks[b->successors[0]].start);
1007 break;
1008 case ZEND_JMPZ:
1009 case ZEND_JMPNZ:
1010 case ZEND_JMPZ_EX:
1011 case ZEND_JMPNZ_EX:
1012 case ZEND_FE_RESET_R:
1013 case ZEND_FE_RESET_RW:
1014 case ZEND_JMP_SET:
1015 case ZEND_COALESCE:
1016 case ZEND_ASSERT_CHECK:
1017 case ZEND_JMP_NULL:
1018 case ZEND_BIND_INIT_STATIC_OR_JMP:
1019 case ZEND_JMP_FRAMELESS:
1020 ZEND_SET_OP_JMP_ADDR(opline, opline->op2, new_opcodes + blocks[b->successors[0]].start);
1021 break;
1022 case ZEND_CATCH:
1023 if (!(opline->extended_value & ZEND_LAST_CATCH)) {
1024 ZEND_SET_OP_JMP_ADDR(opline, opline->op2, new_opcodes + blocks[b->successors[0]].start);
1025 }
1026 break;
1027 case ZEND_FE_FETCH_R:
1028 case ZEND_FE_FETCH_RW:
1029 opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[0]].start);
1030 break;
1031 case ZEND_SWITCH_LONG:
1032 case ZEND_SWITCH_STRING:
1033 case ZEND_MATCH:
1034 {
1035 HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
1036 zval *zv;
1037 uint32_t s = 0;
1038 ZEND_ASSERT(b->successors_count == (opline->opcode == ZEND_MATCH ? 1 : 2) + zend_hash_num_elements(jumptable));
1039
1040 ZEND_HASH_FOREACH_VAL(jumptable, zv) {
1041 Z_LVAL_P(zv) = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start);
1042 } ZEND_HASH_FOREACH_END();
1043 opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start);
1044 break;
1045 }
1046 }
1047 }
1048
1049 /* adjust exception jump targets & remove unused try_catch_array entries */
1050 if (op_array->last_try_catch) {
1051 int i, j;
1052 uint32_t *map;
1053 ALLOCA_FLAG(use_heap);
1054
1055 map = (uint32_t *)do_alloca(sizeof(uint32_t) * op_array->last_try_catch, use_heap);
1056 for (i = 0, j = 0; i< op_array->last_try_catch; i++) {
1057 if (blocks[cfg->map[op_array->try_catch_array[i].try_op]].flags & ZEND_BB_REACHABLE) {
1058 map[i] = j;
1059 op_array->try_catch_array[j].try_op = blocks[cfg->map[op_array->try_catch_array[i].try_op]].start;
1060 if (op_array->try_catch_array[i].catch_op) {
1061 op_array->try_catch_array[j].catch_op = blocks[cfg->map[op_array->try_catch_array[i].catch_op]].start;
1062 } else {
1063 op_array->try_catch_array[j].catch_op = 0;
1064 }
1065 if (op_array->try_catch_array[i].finally_op) {
1066 op_array->try_catch_array[j].finally_op = blocks[cfg->map[op_array->try_catch_array[i].finally_op]].start;
1067 } else {
1068 op_array->try_catch_array[j].finally_op = 0;
1069 }
1070 if (!op_array->try_catch_array[i].finally_end) {
1071 op_array->try_catch_array[j].finally_end = 0;
1072 } else {
1073 op_array->try_catch_array[j].finally_end = blocks[cfg->map[op_array->try_catch_array[i].finally_end]].start;
1074 }
1075 j++;
1076 }
1077 }
1078 if (i != j) {
1079 op_array->last_try_catch = j;
1080 if (j == 0) {
1081 efree(op_array->try_catch_array);
1082 op_array->try_catch_array = NULL;
1083 }
1084
1085 if (op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK) {
1086 zend_op *opline = new_opcodes;
1087 zend_op *end = opline + len;
1088 while (opline < end) {
1089 if (opline->opcode == ZEND_FAST_RET &&
1090 opline->op2.num != (uint32_t)-1 &&
1091 opline->op2.num < (uint32_t)j) {
1092 opline->op2.num = map[opline->op2.num];
1093 }
1094 opline++;
1095 }
1096 }
1097 }
1098 free_alloca(map, use_heap);
1099 }
1100
1101 /* rebuild map (just for printing) */
1102 memset(cfg->map, -1, sizeof(int) * op_array->last);
1103 for (int n = 0; n < cfg->blocks_count; n++) {
1104 if (cfg->blocks[n].flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
1105 cfg->map[cfg->blocks[n].start] = n;
1106 }
1107 }
1108}
1109
1110static zend_always_inline zend_basic_block *get_target_block(const zend_cfg *cfg, zend_basic_block *block, int n, uint32_t *opt_count)
1111{
1112 int b;
1113 zend_basic_block *target_block = cfg->blocks + block->successors[n];
1114
1115 if (target_block->len == 0 && !(target_block->flags & ZEND_BB_PROTECTED)) {
1116 do {
1117 b = target_block->successors[0];
1118 target_block = cfg->blocks + b;
1119 } while (target_block->len == 0 && !(target_block->flags & ZEND_BB_PROTECTED));
1120 block->successors[n] = b;
1121 ++(*opt_count);
1122 }
1123 return target_block;
1124}
1125
1126static zend_always_inline zend_basic_block *get_follow_block(const zend_cfg *cfg, zend_basic_block *block, int n, uint32_t *opt_count)
1127{
1128 int b;
1129 zend_basic_block *target_block = cfg->blocks + block->successors[n];
1130
1131 if (target_block->len == 0 && !(target_block->flags & ZEND_BB_PROTECTED)) {
1132 do {
1133 b = target_block->successors[0];
1134 target_block = cfg->blocks + b;
1135 } while (target_block->len == 0 && !(target_block->flags & ZEND_BB_PROTECTED));
1136 block->successors[n] = b;
1137 ++(*opt_count);
1138 }
1139 return target_block;
1140}
1141
1142static zend_always_inline zend_basic_block *get_next_block(const zend_cfg *cfg, zend_basic_block *block)
1143{
1144 zend_basic_block *next_block = block + 1;
1145 zend_basic_block *end = cfg->blocks + cfg->blocks_count;
1146
1147 while (1) {
1148 if (next_block == end) {
1149 return NULL;
1150 } else if (next_block->flags & ZEND_BB_REACHABLE) {
1151 break;
1152 }
1153 next_block++;
1154 }
1155 while (next_block->len == 0 && !(next_block->flags & ZEND_BB_PROTECTED)) {
1156 next_block = cfg->blocks + next_block->successors[0];
1157 }
1158 return next_block;
1159}
1160
1161
1162/* we use "jmp_hitlist" to avoid infinity loops during jmp optimization */
1163static zend_always_inline bool in_hitlist(int target, int *jmp_hitlist, int jmp_hitlist_count)
1164{
1165 int i;
1166
1167 for (i = 0; i < jmp_hitlist_count; i++) {
1168 if (jmp_hitlist[i] == target) {
1169 return 1;
1170 }
1171 }
1172 return 0;
1173}
1174
1175#define CHECK_LOOP(target) \
1176 if (EXPECTED(!in_hitlist(target, jmp_hitlist, jmp_hitlist_count))) { \
1177 jmp_hitlist[jmp_hitlist_count++] = target; \
1178 } else { \
1179 break; \
1180 }
1181
1182static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_array, const zend_cfg *cfg, int *jmp_hitlist, uint32_t *opt_count)
1183{
1184 /* last_op is the last opcode of the current block */
1185 zend_basic_block *target_block, *follow_block, *next_block;
1186 zend_op *last_op, *target;
1187 int next, jmp_hitlist_count;
1188
1189 if (block->len == 0) {
1190 return;
1191 }
1192
1193 last_op = op_array->opcodes + block->start + block->len - 1;
1194 switch (last_op->opcode) {
1195 case ZEND_JMP:
1196 jmp_hitlist_count = 0;
1197
1198 target_block = get_target_block(cfg, block, 0, opt_count);
1199 while (target_block->len == 1) {
1200 target = op_array->opcodes + target_block->start;
1201 if (target->opcode == ZEND_JMP) {
1202 /* JMP L, L: JMP L1 -> JMP L1 */
1203 next = target_block->successors[0];
1204 } else {
1205 break;
1206 }
1207 CHECK_LOOP(next);
1208 block->successors[0] = next;
1209 ++(*opt_count);
1210 target_block = get_target_block(cfg, block, 0, opt_count);
1211 }
1212
1213 next_block = get_next_block(cfg, block);
1214 if (target_block == next_block) {
1215 /* JMP(next) -> NOP */
1216 MAKE_NOP(last_op);
1217 ++(*opt_count);
1218 block->len--;
1219 } else if (target_block->len == 1) {
1220 target = op_array->opcodes + target_block->start;
1221 if ((target->opcode == ZEND_RETURN ||
1222 target->opcode == ZEND_RETURN_BY_REF ||
1223 target->opcode == ZEND_GENERATOR_RETURN) &&
1224 !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) {
1225 /* JMP L, L: RETURN to immediate RETURN */
1226 *last_op = *target;
1227 if (last_op->op1_type == IS_CONST) {
1228 zval zv;
1229 ZVAL_COPY(&zv, &ZEND_OP1_LITERAL(last_op));
1230 last_op->op1.constant = zend_optimizer_add_literal(op_array, &zv);
1231 }
1232 block->successors_count = 0;
1233 ++(*opt_count);
1234 }
1235 }
1236 break;
1237
1238 case ZEND_JMP_SET:
1239 case ZEND_COALESCE:
1240 case ZEND_JMP_NULL:
1241 jmp_hitlist_count = 0;
1242
1243 target_block = get_target_block(cfg, block, 0, opt_count);
1244 while (target_block->len == 1) {
1245 target = op_array->opcodes + target_block->start;
1246
1247 if (target->opcode == ZEND_JMP) {
1248 /* JMP_SET(X, L), L: JMP(L2) -> JMP_SET(X, L2) */
1249 next = target_block->successors[0];
1250 CHECK_LOOP(next);
1251 block->successors[0] = next;
1252 ++(*opt_count);
1253 } else {
1254 break;
1255 }
1256 target_block = get_target_block(cfg, block, 0, opt_count);
1257 }
1258 break;
1259
1260 case ZEND_JMPZ:
1261 case ZEND_JMPNZ:
1262 jmp_hitlist_count = 0;
1263
1264 target_block = get_target_block(cfg, block, 0, opt_count);
1265 while (target_block->len == 1) {
1266 target = op_array->opcodes + target_block->start;
1267
1268 if (target->opcode == ZEND_JMP) {
1269 /* JMPZ(X, L), L: JMP(L2) -> JMPZ(X, L2) */
1270 next = target_block->successors[0];
1271 } else if (target->opcode == last_op->opcode &&
1272 SAME_VAR(target->op1, last_op->op1)) {
1273 /* JMPZ(X, L), L: JMPZ(X, L2) -> JMPZ(X, L2) */
1274 next = target_block->successors[0];
1275 } else if (target->opcode == INV_COND(last_op->opcode) &&
1276 SAME_VAR(target->op1, last_op->op1)) {
1277 /* JMPZ(X, L), L: JMPNZ(X, L2) -> JMPZ(X, L+1) */
1278 next = target_block->successors[1];
1279 } else {
1280 break;
1281 }
1282 CHECK_LOOP(next);
1283 block->successors[0] = next;
1284 ++(*opt_count);
1285 target_block = get_target_block(cfg, block, 0, opt_count);
1286 }
1287
1288 follow_block = get_follow_block(cfg, block, 1, opt_count);
1289 if (target_block == follow_block) {
1290 /* L: JMP[N]Z(X, L+1) -> NOP or FREE(X) */
1291 zend_optimizer_convert_to_free_op1(op_array, last_op);
1292 if (last_op->opcode == ZEND_NOP) {
1293 block->len--;
1294 }
1295 block->successors_count = 1;
1296 ++(*opt_count);
1297 } else if (follow_block->len == 1) {
1298 target = op_array->opcodes + follow_block->start;
1299 if (target->opcode == ZEND_JMP) {
1300 if (block->successors[0] == follow_block->successors[0]) {
1301 /* JMPZ(X,L1), JMP(L1) -> NOP, JMP(L1) */
1302 zend_optimizer_convert_to_free_op1(op_array, last_op);
1303 if (last_op->opcode == ZEND_NOP) {
1304 block->len--;
1305 }
1306 block->successors[0] = follow_block - cfg->blocks;
1307 block->successors_count = 1;
1308 ++(*opt_count);
1309 break;
1310 } else if (!(follow_block->flags & (ZEND_BB_TARGET | ZEND_BB_PROTECTED))) {
1311 next_block = get_next_block(cfg, follow_block);
1312
1313 if (target_block == next_block) {
1314 /* JMPZ(X,L1) JMP(L2) L1: -> JMPNZ(X,L2) NOP*/
1315
1316 last_op->opcode = INV_COND(last_op->opcode);
1317
1318 block->successors[0] = follow_block->successors[0];
1319 block->successors[1] = next_block - cfg->blocks;
1320
1321 follow_block->flags &= ~ZEND_BB_REACHABLE;
1322 MAKE_NOP(target);
1323 follow_block->len = 0;
1324
1325 next_block->flags |= ZEND_BB_FOLLOW;
1326
1327 break;
1328 }
1329 }
1330 }
1331 }
1332 break;
1333
1334 case ZEND_JMPNZ_EX:
1335 case ZEND_JMPZ_EX:
1336 jmp_hitlist_count = 0;
1337
1338 target_block = get_target_block(cfg, block, 0, opt_count);
1339 while (target_block->len == 1) {
1340 target = op_array->opcodes + target_block->start;
1341
1342 if (target->opcode == ZEND_JMP) {
1343 /* T = JMPZ_EX(X, L), L: JMP(L2) -> T = JMPZ(X, L2) */
1344 next = target_block->successors[0];
1345 } else if (target->opcode == last_op->opcode-3 &&
1346 (SAME_VAR(target->op1, last_op->result) ||
1347 SAME_VAR(target->op1, last_op->op1))) {
1348 /* T = JMPZ_EX(X, L1), L1: JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */
1349 next = target_block->successors[0];
1350 } else if (target->opcode == last_op->opcode &&
1351 target->result.var == last_op->result.var &&
1352 (SAME_VAR(target->op1, last_op->result) ||
1353 SAME_VAR(target->op1, last_op->op1))) {
1354 /* T = JMPZ_EX(X, L1), L1: T = JMPZ_EX({X|T}, L2) -> T = JMPZ_EX(X, L2) */
1355 next = target_block->successors[0];
1356 } else if (target->opcode == INV_EX_COND(last_op->opcode) &&
1357 (SAME_VAR(target->op1, last_op->result) ||
1358 SAME_VAR(target->op1, last_op->op1))) {
1359 /* T = JMPZ_EX(X, L1), L1: JMPNZ({X|T1}, L2) -> T = JMPZ_EX(X, L1+1) */
1360 next = target_block->successors[1];
1361 } else if (target->opcode == INV_EX_COND_EX(last_op->opcode) &&
1362 target->result.var == last_op->result.var &&
1363 (SAME_VAR(target->op1, last_op->result) ||
1364 SAME_VAR(target->op1, last_op->op1))) {
1365 /* T = JMPZ_EX(X, L1), L1: T = JMPNZ_EX({X|T}, L2) -> T = JMPZ_EX(X, L1+1) */
1366 next = target_block->successors[1];
1367 } else if (target->opcode == ZEND_BOOL &&
1368 (SAME_VAR(target->op1, last_op->result) ||
1369 SAME_VAR(target->op1, last_op->op1))) {
1370 /* convert Y = JMPZ_EX(X,L1), L1: Z = BOOL(Y) to
1371 Z = JMPZ_EX(X,L1+1) */
1372
1373 /* NOTE: This optimization pattern is not safe, but works, */
1374 /* because result of JMPZ_EX instruction */
1375 /* is not used on the following path and */
1376 /* should be used once on the branch path. */
1377 /* */
1378 /* The pattern works well only if jumps processed in */
1379 /* direct order, otherwise it breaks JMPZ_EX */
1380 /* sequences too early. */
1381 last_op->result.var = target->result.var;
1382 next = target_block->successors[0];
1383 } else {
1384 break;
1385 }
1386 CHECK_LOOP(next);
1387 block->successors[0] = next;
1388 ++(*opt_count);
1389 target_block = get_target_block(cfg, block, 0, opt_count);
1390 }
1391
1392 follow_block = get_follow_block(cfg, block, 1, opt_count);
1393 if (target_block == follow_block) {
1394 /* L: T = JMP[N]Z_EX(X, L+1) -> T = BOOL(X) */
1395 last_op->opcode = ZEND_BOOL;
1396 last_op->op2.num = 0;
1397 block->successors_count = 1;
1398 ++(*opt_count);
1399 break;
1400 }
1401 break;
1402 }
1403}
1404
1405/* Global data dependencies */
1406
1407/* Find a set of variables which are used outside of the block where they are
1408 * defined. We won't apply some optimization patterns for such variables. */
1409static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset used_ext, zend_optimizer_ctx *ctx)
1410{
1411 int n;
1412 zend_basic_block *block, *next_block;
1413 uint32_t var_num;
1414 uint32_t bitset_len;
1415 zend_bitset usage;
1416 zend_bitset defined_here;
1417 void *checkpoint;
1418 zend_op *opline, *end;
1419
1420
1421 if (op_array->T == 0) {
1422 /* shortcut - if no Ts, nothing to do */
1423 return;
1424 }
1425
1426 checkpoint = zend_arena_checkpoint(ctx->arena);
1427 bitset_len = zend_bitset_len(op_array->last_var + op_array->T);
1428 defined_here = zend_arena_alloc(&ctx->arena, bitset_len * ZEND_BITSET_ELM_SIZE);
1429
1430 zend_bitset_clear(defined_here, bitset_len);
1431 for (n = 1; n < cfg->blocks_count; n++) {
1432 block = cfg->blocks + n;
1433
1434 if (!(block->flags & ZEND_BB_REACHABLE)) {
1435 continue;
1436 }
1437
1438 opline = op_array->opcodes + block->start;
1439 end = opline + block->len;
1440 if (!(block->flags & ZEND_BB_FOLLOW) ||
1441 (block->flags & ZEND_BB_TARGET)) {
1442 /* Skip continuation of "extended" BB */
1443 zend_bitset_clear(defined_here, bitset_len);
1444 }
1445
1446 while (opline<end) {
1447 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
1448 var_num = VAR_NUM(opline->op1.var);
1449 if (!zend_bitset_in(defined_here, var_num)) {
1450 zend_bitset_incl(used_ext, var_num);
1451 }
1452 }
1453 if (opline->op2_type == IS_VAR) {
1454 var_num = VAR_NUM(opline->op2.var);
1455 if (opline->opcode == ZEND_FE_FETCH_R ||
1456 opline->opcode == ZEND_FE_FETCH_RW) {
1457 /* these opcode use the op2 as result */
1458 zend_bitset_incl(defined_here, var_num);
1459 } else if (!zend_bitset_in(defined_here, var_num)) {
1460 zend_bitset_incl(used_ext, var_num);
1461 }
1462 } else if (opline->op2_type == IS_TMP_VAR) {
1463 var_num = VAR_NUM(opline->op2.var);
1464 if (!zend_bitset_in(defined_here, var_num)) {
1465 zend_bitset_incl(used_ext, var_num);
1466 }
1467 }
1468
1469 if (opline->result_type == IS_VAR) {
1470 var_num = VAR_NUM(opline->result.var);
1471 zend_bitset_incl(defined_here, var_num);
1472 } else if (opline->result_type == IS_TMP_VAR) {
1473 var_num = VAR_NUM(opline->result.var);
1474 switch (opline->opcode) {
1475 case ZEND_ADD_ARRAY_ELEMENT:
1476 case ZEND_ADD_ARRAY_UNPACK:
1477 case ZEND_ROPE_ADD:
1478 /* these opcodes use the result as argument */
1479 if (!zend_bitset_in(defined_here, var_num)) {
1480 zend_bitset_incl(used_ext, var_num);
1481 }
1482 break;
1483 default :
1484 zend_bitset_incl(defined_here, var_num);
1485 }
1486 }
1487 opline++;
1488 }
1489 }
1490
1491 if (ctx->debug_level & ZEND_DUMP_BLOCK_PASS_VARS) {
1492 bool printed = 0;
1493 uint32_t i;
1494
1495 for (i = op_array->last_var; i< op_array->T; i++) {
1496 if (zend_bitset_in(used_ext, i)) {
1497 if (!printed) {
1498 fprintf(stderr, "NON-LOCAL-VARS: %d", i);
1499 printed = 1;
1500 } else {
1501 fprintf(stderr, ", %d", i);
1502 }
1503 }
1504 }
1505 if (printed) {
1506 fprintf(stderr, "\n");
1507 }
1508 }
1509
1510 usage = defined_here;
1511 next_block = NULL;
1512 for (n = cfg->blocks_count; n > 0;) {
1513 block = cfg->blocks + (--n);
1514
1515 if (!(block->flags & ZEND_BB_REACHABLE) || block->len == 0) {
1516 continue;
1517 }
1518
1519 end = op_array->opcodes + block->start;
1520 opline = end + block->len - 1;
1521 if (!next_block ||
1522 !(next_block->flags & ZEND_BB_FOLLOW) ||
1523 (next_block->flags & ZEND_BB_TARGET)) {
1524 /* Skip continuation of "extended" BB */
1525 zend_bitset_copy(usage, used_ext, bitset_len);
1526 } else if (block->successors_count > 1) {
1527 zend_bitset_union(usage, used_ext, bitset_len);
1528 }
1529 next_block = block;
1530
1531 while (opline >= end) {
1532 /* usage checks */
1533 if (opline->result_type & (IS_VAR|IS_TMP_VAR)) {
1534 if (!zend_bitset_in(usage, VAR_NUM(opline->result.var))) {
1535 switch (opline->opcode) {
1536 case ZEND_ASSIGN_OP:
1537 case ZEND_ASSIGN_DIM_OP:
1538 case ZEND_ASSIGN_OBJ_OP:
1539 case ZEND_ASSIGN_STATIC_PROP_OP:
1540 case ZEND_PRE_INC:
1541 case ZEND_PRE_DEC:
1542 case ZEND_ASSIGN:
1543 case ZEND_ASSIGN_REF:
1544 case ZEND_DO_FCALL:
1545 case ZEND_DO_ICALL:
1546 case ZEND_DO_UCALL:
1547 case ZEND_DO_FCALL_BY_NAME:
1548 opline->result_type = IS_UNUSED;
1549 break;
1550 case ZEND_POST_INC:
1551 case ZEND_POST_DEC:
1552 case ZEND_POST_INC_OBJ:
1553 case ZEND_POST_DEC_OBJ:
1554 case ZEND_POST_INC_STATIC_PROP:
1555 case ZEND_POST_DEC_STATIC_PROP:
1556 opline->opcode -= 2;
1557 opline->result_type = IS_UNUSED;
1558 break;
1559 case ZEND_QM_ASSIGN:
1560 case ZEND_BOOL:
1561 case ZEND_BOOL_NOT:
1562 zend_optimizer_convert_to_free_op1(op_array, opline);
1563 break;
1564 case ZEND_JMPZ_EX:
1565 case ZEND_JMPNZ_EX:
1566 opline->opcode -= 3;
1567 SET_UNUSED(opline->result);
1568 break;
1569 case ZEND_ADD_ARRAY_ELEMENT:
1570 case ZEND_ADD_ARRAY_UNPACK:
1571 case ZEND_ROPE_ADD:
1572 zend_bitset_incl(usage, VAR_NUM(opline->result.var));
1573 break;
1574 }
1575 } else {
1576 switch (opline->opcode) {
1577 case ZEND_ADD_ARRAY_ELEMENT:
1578 case ZEND_ADD_ARRAY_UNPACK:
1579 case ZEND_ROPE_ADD:
1580 break;
1581 default:
1582 zend_bitset_excl(usage, VAR_NUM(opline->result.var));
1583 break;
1584 }
1585 }
1586 }
1587
1588 if (opline->op2_type == IS_VAR) {
1589 switch (opline->opcode) {
1590 case ZEND_FE_FETCH_R:
1591 case ZEND_FE_FETCH_RW:
1592 zend_bitset_excl(usage, VAR_NUM(opline->op2.var));
1593 break;
1594 default:
1595 zend_bitset_incl(usage, VAR_NUM(opline->op2.var));
1596 break;
1597 }
1598 } else if (opline->op2_type == IS_TMP_VAR) {
1599 zend_bitset_incl(usage, VAR_NUM(opline->op2.var));
1600 }
1601
1602 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
1603 zend_bitset_incl(usage, VAR_NUM(opline->op1.var));
1604 }
1605
1606 opline--;
1607 }
1608 }
1609
1610 zend_arena_release(&ctx->arena, checkpoint);
1611}
1612
1613static void zend_merge_blocks(zend_op_array *op_array, zend_cfg *cfg, uint32_t *opt_count)
1614{
1615 int i;
1616 zend_basic_block *b, *bb;
1617 zend_basic_block *prev = NULL;
1618
1619 for (i = 0; i < cfg->blocks_count; i++) {
1620 b = cfg->blocks + i;
1621 if (b->flags & ZEND_BB_REACHABLE) {
1622 if ((b->flags & ZEND_BB_FOLLOW) &&
1623 !(b->flags & (ZEND_BB_TARGET | ZEND_BB_PROTECTED)) &&
1624 prev && prev->successors_count == 1 && prev->successors[0] == i)
1625 {
1626 zend_op *last_op = op_array->opcodes + prev->start + prev->len - 1;
1627 if (prev->len != 0 && last_op->opcode == ZEND_JMP) {
1628 MAKE_NOP(last_op);
1629 }
1630
1631 for (bb = prev + 1; bb != b; bb++) {
1632 zend_op *op = op_array->opcodes + bb->start;
1633 zend_op *end = op + bb->len;
1634 while (op < end) {
1635 if (op->op1_type == IS_CONST) {
1636 literal_dtor(&ZEND_OP1_LITERAL(op));
1637 }
1638 if (op->op2_type == IS_CONST) {
1639 literal_dtor(&ZEND_OP2_LITERAL(op));
1640 }
1641 MAKE_NOP(op);
1642 op++;
1643 }
1644 /* make block empty */
1645 bb->len = 0;
1646 }
1647
1648 /* re-link */
1649 prev->flags |= (b->flags & ZEND_BB_EXIT);
1650 prev->len = b->start + b->len - prev->start;
1651 prev->successors_count = b->successors_count;
1652 if (b->successors != b->successors_storage) {
1653 prev->successors = b->successors;
1654 b->successors = b->successors_storage;
1655 } else {
1656 memcpy(prev->successors, b->successors, b->successors_count * sizeof(int));
1657 }
1658
1659 /* unlink & make block empty and unreachable */
1660 b->flags = 0;
1661 b->len = 0;
1662 b->successors_count = 0;
1663 ++(*opt_count);
1664 } else {
1665 prev = b;
1666 }
1667 }
1668 }
1669}
1670
1671#define PASSES 3
1672
1673void zend_optimize_cfg(zend_op_array *op_array, zend_optimizer_ctx *ctx)
1674{
1675 zend_cfg cfg;
1676 zend_basic_block *blocks, *end, *b;
1677 int pass;
1678 uint32_t bitset_len;
1679 zend_bitset usage;
1680 void *checkpoint;
1681 zend_op **Tsource;
1682 uint32_t opt_count;
1683 int *jmp_hitlist;
1684
1685 /* Build CFG */
1686 checkpoint = zend_arena_checkpoint(ctx->arena);
1687 zend_build_cfg(&ctx->arena, op_array, 0, &cfg);
1688
1689 if (cfg.blocks_count * (op_array->last_var + op_array->T) > 64 * 1024 * 1024) {
1690 zend_arena_release(&ctx->arena, checkpoint);
1691 return;
1692 }
1693
1694 if (ctx->debug_level & ZEND_DUMP_BEFORE_BLOCK_PASS) {
1695 zend_dump_op_array(op_array, ZEND_DUMP_CFG, "before block pass", &cfg);
1696 }
1697
1698 bitset_len = zend_bitset_len(op_array->last_var + op_array->T);
1699 Tsource = zend_arena_calloc(&ctx->arena, op_array->last_var + op_array->T, sizeof(zend_op *));
1700 usage = zend_arena_alloc(&ctx->arena, bitset_len * ZEND_BITSET_ELM_SIZE);
1701 jmp_hitlist = zend_arena_alloc(&ctx->arena, cfg.blocks_count * sizeof(int));
1702
1703 blocks = cfg.blocks;
1704 end = blocks + cfg.blocks_count;
1705 for (pass = 0; pass < PASSES; pass++) {
1706 opt_count = 0;
1707
1708 /* Compute data dependencies */
1709 zend_bitset_clear(usage, bitset_len);
1710 zend_t_usage(&cfg, op_array, usage, ctx);
1711
1712 /* optimize each basic block separately */
1713 for (b = blocks; b < end; b++) {
1714 if (!(b->flags & ZEND_BB_REACHABLE)) {
1715 continue;
1716 }
1717 /* we track data dependencies only inside a single basic block */
1718 if (!(b->flags & ZEND_BB_FOLLOW) ||
1719 (b->flags & ZEND_BB_TARGET)) {
1720 /* Skip continuation of "extended" BB */
1721 memset(Tsource, 0, (op_array->last_var + op_array->T) * sizeof(zend_op *));
1722 }
1723 zend_optimize_block(b, op_array, usage, &cfg, Tsource, &opt_count);
1724 }
1725
1726 /* Eliminate NOPs */
1727 for (b = blocks; b < end; b++) {
1728 if (b->flags & ZEND_BB_UNREACHABLE_FREE) {
1729 /* In unreachable_free blocks only preserve loop var frees. */
1730 for (uint32_t i = b->start; i < b->start + b->len; i++) {
1731 zend_op *opline = &op_array->opcodes[i];
1732 if (!zend_optimizer_is_loop_var_free(opline)) {
1733 MAKE_NOP(opline);
1734 }
1735 }
1736 }
1737 if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
1738 strip_nops(op_array, b);
1739 }
1740 }
1741
1742 opt_count = 0;
1743
1744 /* Jump optimization for each block */
1745 for (b = blocks; b < end; b++) {
1746 if (b->flags & ZEND_BB_REACHABLE) {
1747 zend_jmp_optimization(b, op_array, &cfg, jmp_hitlist, &opt_count);
1748 }
1749 }
1750
1751 /* Eliminate unreachable basic blocks */
1752 zend_cfg_remark_reachable_blocks(op_array, &cfg);
1753
1754 /* Merge Blocks */
1755 zend_merge_blocks(op_array, &cfg, &opt_count);
1756
1757 if (opt_count == 0) {
1758 break;
1759 }
1760 }
1761
1762 assemble_code_blocks(&cfg, op_array, ctx);
1763
1764 if (ctx->debug_level & ZEND_DUMP_AFTER_BLOCK_PASS) {
1765 zend_dump_op_array(op_array, ZEND_DUMP_CFG | ZEND_DUMP_HIDE_UNREACHABLE, "after block pass", &cfg);
1766 }
1767
1768 /* Destroy CFG */
1769 zend_arena_release(&ctx->arena, checkpoint);
1770}
len
size_t len
Definition apprentice.c:174
fprintf
fprintf($stream, string $format, mixed ... $values)
Definition basic_functions.stub.php:2989
prev
prev(array|object &$array)
Definition basic_functions.stub.php:1602
copy
copy(string $from, string $to, $context=null)
Definition basic_functions.stub.php:2843
SET_VAR_SOURCE
#define SET_VAR_SOURCE(opline)
Definition block_pass.c:63
PASSES
#define PASSES
Definition block_pass.c:1671
CHECK_LOOP
#define CHECK_LOOP(target)
Definition block_pass.c:1175
zend_optimize_cfg
void zend_optimize_cfg(zend_op_array *op_array, zend_optimizer_ctx *ctx)
Definition block_pass.c:1673
VAR_SOURCE
#define VAR_SOURCE(op)
Definition block_pass.c:62
zend_optimizer_get_persistent_constant
bool zend_optimizer_get_persistent_constant(zend_string *name, zval *result, int copy)
Definition block_pass.c:33
s
char s[4]
Definition cdf.c:77
zv
zval * zv
Definition ffi.c:3975
n
zend_long n
Definition ffi.c:4979
memcpy
memcpy(ptr1, ptr2, size)
arg
zval * arg
Definition ffi.c:3975
memset
memset(ptr, 0, type->size)
val
zval * val
Definition ffi.c:4262
start
buf start
Definition ffi.c:4687
T
#define T
Definition encoding.c:236
NULL
#define NULL
Definition gdcache.h:45
SUCCESS
#define SUCCESS
Definition hash_sha3.c:261
pass
#define pass(a, b, c, mul)
Definition hash_tiger.c:50
j
again j
Definition html_table_gen.php:365
next
#define next(ls)
Definition minilua.c:2661
end
unsigned const char * end
Definition php_ffi.h:51
_zend_basic_block::successors_storage
int successors_storage[2]
Definition zend_cfg.h:55
_zend_basic_block::start
uint32_t start
Definition zend_cfg.h:45
_zend_basic_block::successors
int * successors
Definition zend_cfg.h:43
_zend_basic_block::len
uint32_t len
Definition zend_cfg.h:46
_zend_basic_block::successors_count
int successors_count
Definition zend_cfg.h:47
_zend_basic_block::flags
uint32_t flags
Definition zend_cfg.h:44
_zend_cfg::map
uint32_t * map
Definition zend_cfg.h:89
_zend_cfg::blocks_count
int blocks_count
Definition zend_cfg.h:85
_zend_cfg::blocks
zend_basic_block * blocks
Definition zend_cfg.h:87
_zend_constant::value
zval value
Definition zend_constants.h:34
_zend_op_array::last
uint32_t last
Definition zend_compile.h:525
_zend_op_array::try_catch_array
zend_try_catch_element * try_catch_array
Definition zend_compile.h:537
_zend_op_array::last_var
int last_var
Definition zend_compile.h:524
_zend_op_array::opcodes
zend_op * opcodes
Definition zend_compile.h:527
_zend_op_array::T
uint32_t T
Definition zend_compile.h:519
_zend_op_array::last_try_catch
int last_try_catch
Definition zend_compile.h:535
_zend_op_array::fn_flags
uint32_t fn_flags
Definition zend_compile.h:509
_zend_op::op1
znode_op op1
Definition zend_compile.h:139
_zend_op::result_type
uint8_t result_type
Definition zend_compile.h:147
_zend_op::op2
znode_op op2
Definition zend_compile.h:140
_zend_op::result
znode_op result
Definition zend_compile.h:141
_zend_op::opcode
uint8_t opcode
Definition zend_compile.h:144
_zend_op::op1_type
uint8_t op1_type
Definition zend_compile.h:145
_zend_op::extended_value
uint32_t extended_value
Definition zend_compile.h:142
_zend_op::op2_type
uint8_t op2_type
Definition zend_compile.h:146
_zend_optimizer_ctx::arena
zend_arena * arena
Definition zend_optimizer_internal.h:47
_zend_optimizer_ctx::debug_level
zend_long debug_level
Definition zend_optimizer_internal.h:51
_zend_try_catch_element::finally_end
uint32_t finally_end
Definition zend_compile.h:176
_zend_try_catch_element::finally_op
uint32_t finally_op
Definition zend_compile.h:175
_zend_try_catch_element::catch_op
uint32_t catch_op
Definition zend_compile.h:174
_zend_try_catch_element::try_op
uint32_t try_op
Definition zend_compile.h:173
_znode_op::var
uint32_t var
Definition zend_compile.h:70
_znode_op::constant
uint32_t constant
Definition zend_compile.h:69
_znode_op::num
uint32_t num
Definition zend_compile.h:71
module_registry
ZEND_API HashTable module_registry
Definition zend_API.c:41
zend_API.h
efree
#define efree(ptr)
Definition zend_alloc.h:155
emalloc
#define emalloc(size)
Definition zend_alloc.h:151
zend_bitset.h
zend_bitset
zend_ulong * zend_bitset
Definition zend_bitset.h:29
ZEND_BITSET_ELM_SIZE
#define ZEND_BITSET_ELM_SIZE
Definition zend_bitset.h:31
zval
struct _zval_struct zval
Definition zend_builtin_functions.h:25
zend_build_cfg
ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t build_flags, zend_cfg *cfg)
Definition zend_cfg.c:273
zend_cfg_remark_reachable_blocks
void zend_cfg_remark_reachable_blocks(const zend_op_array *op_array, zend_cfg *cfg)
Definition zend_cfg.c:232
zend_cfg.h
zend_basic_block
struct _zend_basic_block zend_basic_block
ZEND_BB_REACHABLE
#define ZEND_BB_REACHABLE
Definition zend_cfg.h:38
ZEND_BB_UNREACHABLE_FREE
#define ZEND_BB_UNREACHABLE_FREE
Definition zend_cfg.h:32
ZEND_BB_EXIT
#define ZEND_BB_EXIT
Definition zend_cfg.h:26
zend_cfg
struct _zend_cfg zend_cfg
ZEND_BB_PROTECTED
#define ZEND_BB_PROTECTED
Definition zend_cfg.h:40
ZEND_BB_FOLLOW
#define ZEND_BB_FOLLOW
Definition zend_cfg.h:24
ZEND_BB_TARGET
#define ZEND_BB_TARGET
Definition zend_cfg.h:25
zend_op
struct _zend_op zend_op
Definition zend_compile.h:55
IS_UNUSED
#define IS_UNUSED
Definition zend_compile.h:833
ZEND_SET_OP_JMP_ADDR
#define ZEND_SET_OP_JMP_ADDR(opline, node, val)
Definition zend_compile.h:769
IS_CONST
#define IS_CONST
Definition zend_compile.h:834
IS_VAR
#define IS_VAR
Definition zend_compile.h:836
ZEND_OFFSET_TO_OPLINE_NUM
#define ZEND_OFFSET_TO_OPLINE_NUM(op_array, base, offset)
Definition zend_compile.h:740
zend_op_array
struct _zend_op_array zend_op_array
Definition zend_compile.h:54
znode_op
union _znode_op znode_op
ZEND_COMPILE_WITH_FILE_CACHE
#define ZEND_COMPILE_WITH_FILE_CACHE
Definition zend_compile.h:1270
MAKE_NOP
#define MAKE_NOP(opline)
Definition zend_compile.h:40
ZEND_OPLINE_TO_OFFSET
#define ZEND_OPLINE_TO_OFFSET(opline, target)
Definition zend_compile.h:731
SET_UNUSED
#define SET_UNUSED(op)
Definition zend_compile.h:35
IS_TMP_VAR
#define IS_TMP_VAR
Definition zend_compile.h:835
ZEND_ACC_HAS_FINALLY_BLOCK
#define ZEND_ACC_HAS_FINALLY_BLOCK
Definition zend_compile.h:352
ZEND_LAST_CATCH
#define ZEND_LAST_CATCH
Definition zend_compile.h:1093
zend_constants.h
ZEND_CONSTANT_FLAGS
#define ZEND_CONSTANT_FLAGS(c)
Definition zend_constants.h:38
CONST_NO_FILE_CACHE
#define CONST_NO_FILE_CACHE
Definition zend_constants.h:27
CONST_PERSISTENT
#define CONST_PERSISTENT
Definition zend_constants.h:26
zend_constant
struct _zend_constant zend_constant
CONST_DEPRECATED
#define CONST_DEPRECATED
Definition zend_constants.h:28
zend_dump_op_array
ZEND_API void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, const char *msg, const void *data)
Definition zend_dump.c:930
zend_dump.h
ZEND_DUMP_HIDE_UNREACHABLE
#define ZEND_DUMP_HIDE_UNREACHABLE
Definition zend_dump.h:27
ZEND_DUMP_CFG
#define ZEND_DUMP_CFG
Definition zend_dump.h:29
zend_execute.h
zend_function
union _zend_function zend_function
Definition zend_frameless_function.h:108
CG
#define CG(v)
Definition zend_globals_macros.h:36
EG
#define EG(v)
Definition zend_globals_macros.h:46
zend_hash_find
ZEND_API zval *ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key)
Definition zend_hash.c:2668
zend_hash_index_find
ZEND_API zval *ZEND_FASTCALL zend_hash_index_find(const HashTable *ht, zend_ulong h)
Definition zend_hash.c:2701
ZEND_HASH_FOREACH_END
#define ZEND_HASH_FOREACH_END()
Definition zend_hash.h:1086
ZEND_HASH_FOREACH_VAL
#define ZEND_HASH_FOREACH_VAL(ht, _val)
Definition zend_hash.h:1102
zend_string
struct _zend_string zend_string
Definition zend_map_ptr.h:24
zend_binary_strcasecmp
ZEND_API int ZEND_FASTCALL zend_binary_strcasecmp(const char *s1, size_t len1, const char *s2, size_t len2)
Definition zend_operators.c:3189
zend_is_true
ZEND_API bool ZEND_FASTCALL zend_is_true(const zval *op)
Definition zend_operators.c:2819
convert_to_string
#define convert_to_string(op)
Definition zend_operators.h:385
zend_optimizer_update_op1_const
bool zend_optimizer_update_op1_const(zend_op_array *op_array, zend_op *opline, zval *val)
Definition zend_optimizer.c:277
zend_optimizer_eval_strlen
zend_result zend_optimizer_eval_strlen(zval *result, const zval *op1)
Definition zend_optimizer.c:115
zend_optimizer_add_literal
int zend_optimizer_add_literal(zend_op_array *op_array, const zval *zv)
Definition zend_optimizer.c:233
zend_optimizer_eval_binary_op
zend_result zend_optimizer_eval_binary_op(zval *result, uint8_t opcode, zval *op1, zval *op2)
Definition zend_optimizer.c:56
zend_optimizer_eval_cast
zend_result zend_optimizer_eval_cast(zval *result, uint32_t type, zval *op1)
Definition zend_optimizer.c:83
zend_optimizer_convert_to_free_op1
void zend_optimizer_convert_to_free_op1(zend_op_array *op_array, zend_op *opline)
Definition zend_optimizer.c:214
zend_optimizer_eval_unary_op
zend_result zend_optimizer_eval_unary_op(zval *result, uint8_t opcode, zval *op1)
Definition zend_optimizer.c:67
zend_optimizer_update_op2_const
bool zend_optimizer_update_op2_const(zend_op_array *op_array, zend_op *opline, zval *val)
Definition zend_optimizer.c:438
zend_optimizer.h
ZEND_DUMP_AFTER_BLOCK_PASS
#define ZEND_DUMP_AFTER_BLOCK_PASS
Definition zend_optimizer.h:73
ZEND_DUMP_BLOCK_PASS_VARS
#define ZEND_DUMP_BLOCK_PASS_VARS
Definition zend_optimizer.h:74
ZEND_DUMP_BEFORE_BLOCK_PASS
#define ZEND_DUMP_BEFORE_BLOCK_PASS
Definition zend_optimizer.h:72
zend_optimizer_internal.h
literal_dtor
#define literal_dtor(zv)
Definition zend_optimizer_internal.h:66
INV_EX_COND_EX
#define INV_EX_COND_EX(op)
Definition zend_optimizer_internal.h:41
ZEND_OP1_LITERAL
#define ZEND_OP1_LITERAL(opline)
Definition zend_optimizer_internal.h:30
ZEND_OP2_LITERAL
#define ZEND_OP2_LITERAL(opline)
Definition zend_optimizer_internal.h:32
INV_EX_COND
#define INV_EX_COND(op)
Definition zend_optimizer_internal.h:39
VAR_NUM
#define VAR_NUM(v)
Definition zend_optimizer_internal.h:35
SAME_VAR
#define SAME_VAR(op1, op2)
Definition zend_optimizer_internal.h:44
INV_COND
#define INV_COND(op)
Definition zend_optimizer_internal.h:38
zend_optimizer_ctx
struct _zend_optimizer_ctx zend_optimizer_ctx
COPY_NODE
#define COPY_NODE(target, src)
Definition zend_optimizer_internal.h:71
LITERAL_BOOL
#define LITERAL_BOOL(op, val)
Definition zend_optimizer_internal.h:60
ALLOCA_FLAG
#define ALLOCA_FLAG(name)
Definition zend_portability.h:218
ZEND_FALLTHROUGH
#define ZEND_FALLTHROUGH
Definition zend_portability.h:125
do_alloca
#define do_alloca(p, use_heap)
Definition zend_portability.h:220
zend_always_inline
#define zend_always_inline
Definition zend_portability.h:375
ZEND_ASSERT
#define ZEND_ASSERT(c)
Definition zend_portability.h:106
free_alloca
#define free_alloca(p, use_heap)
Definition zend_portability.h:221
zend_new_interned_string
ZEND_API zend_new_interned_string_func_t zend_new_interned_string
Definition zend_string.c:30
ZSTR_VAL
#define ZSTR_VAL(zstr)
Definition zend_string.h:68
ZSTR_LEN
#define ZSTR_LEN(zstr)
Definition zend_string.h:69
Z_TYPE_P
#define Z_TYPE_P(zval_p)
Definition zend_types.h:660
IS_TRUE
#define IS_TRUE
Definition zend_types.h:603
ZVAL_STR
#define ZVAL_STR(z, s)
Definition zend_types.h:1078
Z_TRY_ADDREF_P
#define Z_TRY_ADDREF_P(pz)
Definition zend_types.h:1275
IS_FALSE
#define IS_FALSE
Definition zend_types.h:602
ZVAL_NULL
#define ZVAL_NULL(z)
Definition zend_types.h:1049
IS_STRING
#define IS_STRING
Definition zend_types.h:606
HashTable
struct _zend_array HashTable
Definition zend_types.h:386
IS_DOUBLE
#define IS_DOUBLE
Definition zend_types.h:605
Z_STR_P
#define Z_STR_P(zval_p)
Definition zend_types.h:972
Z_STR
#define Z_STR(zval)
Definition zend_types.h:971
Z_REFCOUNTED
#define Z_REFCOUNTED(zval)
Definition zend_types.h:917
IS_STRING_EX
#define IS_STRING_EX
Definition zend_types.h:807
Z_STRVAL
#define Z_STRVAL(zval)
Definition zend_types.h:974
Z_STRLEN
#define Z_STRLEN(zval)
Definition zend_types.h:977
IS_LONG
#define IS_LONG
Definition zend_types.h:604
ZVAL_COPY
#define ZVAL_COPY(z, v)
Definition zend_types.h:1412
Z_TYPE_INFO
#define Z_TYPE_INFO(zval)
Definition zend_types.h:668
Z_TYPE
#define Z_TYPE(zval)
Definition zend_types.h:659
Z_ARRVAL
#define Z_ARRVAL(zval)
Definition zend_types.h:986
Z_LVAL_P
#define Z_LVAL_P(zval_p)
Definition zend_types.h:966
ZVAL_COPY_VALUE
#define ZVAL_COPY_VALUE(z, v)
Definition zend_types.h:1403
ZVAL_BOOL
#define ZVAL_BOOL(z, b)
Definition zend_types.h:1061
Z_LVAL
#define Z_LVAL(zval)
Definition zend_types.h:965
zend_vm.h
name
zend_string * name
Definition zend_vm_def.h:2429
result
bool result
Definition zend_vm_def.h:455
op2
op2
Definition zend_vm_def.h:172
function
function(EX_VAR(opline->result.var))
op1
op1
Definition zend_vm_def.h:171
usage
usage()
Definition zend_vm_gen.php:3039
ZEND_SL
#define ZEND_SL
Definition zend_vm_opcodes.h:92
ZEND_IS_IDENTICAL
#define ZEND_IS_IDENTICAL
Definition zend_vm_opcodes.h:102
ZEND_FETCH_CONSTANT
#define ZEND_FETCH_CONSTANT
Definition zend_vm_opcodes.h:183
ZEND_FETCH_THIS
#define ZEND_FETCH_THIS
Definition zend_vm_opcodes.h:268
ZEND_SWITCH_LONG
#define ZEND_SWITCH_LONG
Definition zend_vm_opcodes.h:271
ZEND_ASSIGN_DIM_OP
#define ZEND_ASSIGN_DIM_OP
Definition zend_vm_opcodes.h:113
ZEND_ISSET_ISEMPTY_CV
#define ZEND_ISSET_ISEMPTY_CV
Definition zend_vm_opcodes.h:238
ZEND_PRE_DEC_OBJ
#define ZEND_PRE_DEC_OBJ
Definition zend_vm_opcodes.h:217
ZEND_BOOL_NOT
#define ZEND_BOOL_NOT
Definition zend_vm_opcodes.h:100
ZEND_NEW
#define ZEND_NEW
Definition zend_vm_opcodes.h:153
ZEND_FE_FETCH_RW
#define ZEND_FE_FETCH_RW
Definition zend_vm_opcodes.h:210
ZEND_VERIFY_RETURN_TYPE
#define ZEND_VERIFY_RETURN_TYPE
Definition zend_vm_opcodes.h:208
ZEND_FETCH_LIST_R
#define ZEND_FETCH_LIST_R
Definition zend_vm_opcodes.h:182
ZEND_RETURN
#define ZEND_RETURN
Definition zend_vm_opcodes.h:147
ZEND_FE_RESET_RW
#define ZEND_FE_RESET_RW
Definition zend_vm_opcodes.h:209
ZEND_FE_FETCH_R
#define ZEND_FE_FETCH_R
Definition zend_vm_opcodes.h:163
ZEND_FETCH_R
#define ZEND_FETCH_R
Definition zend_vm_opcodes.h:164
ZEND_FETCH_LIST_W
#define ZEND_FETCH_LIST_W
Definition zend_vm_opcodes.h:239
ZEND_ASSERT_CHECK
#define ZEND_ASSERT_CHECK
Definition zend_vm_opcodes.h:235
ZEND_SEND_VAL
#define ZEND_SEND_VAL
Definition zend_vm_opcodes.h:150
ZEND_RETURN_BY_REF
#define ZEND_RETURN_BY_REF
Definition zend_vm_opcodes.h:195
ZEND_SWITCH_STRING
#define ZEND_SWITCH_STRING
Definition zend_vm_opcodes.h:272
ZEND_BOOL_XOR
#define ZEND_BOOL_XOR
Definition zend_vm_opcodes.h:101
ZEND_ASSIGN_DIM
#define ZEND_ASSIGN_DIM
Definition zend_vm_opcodes.h:109
ZEND_NOP
#define ZEND_NOP
Definition zend_vm_opcodes.h:86
ZEND_JMPZ
#define ZEND_JMPZ
Definition zend_vm_opcodes.h:129
ZEND_PRE_INC_OBJ
#define ZEND_PRE_INC_OBJ
Definition zend_vm_opcodes.h:216
ZEND_FETCH_STATIC_PROP_R
#define ZEND_FETCH_STATIC_PROP_R
Definition zend_vm_opcodes.h:257
ZEND_PRE_DEC_STATIC_PROP
#define ZEND_PRE_DEC_STATIC_PROP
Definition zend_vm_opcodes.h:125
ZEND_ASSIGN_REF
#define ZEND_ASSIGN_REF
Definition zend_vm_opcodes.h:116
ZEND_ASSIGN_STATIC_PROP_OP
#define ZEND_ASSIGN_STATIC_PROP_OP
Definition zend_vm_opcodes.h:115
ZEND_JMP_SET
#define ZEND_JMP_SET
Definition zend_vm_opcodes.h:236
ZEND_SUB
#define ZEND_SUB
Definition zend_vm_opcodes.h:88
ZEND_JMPZ_EX
#define ZEND_JMPZ_EX
Definition zend_vm_opcodes.h:131
ZEND_IS_SMALLER
#define ZEND_IS_SMALLER
Definition zend_vm_opcodes.h:106
ZEND_PRE_INC
#define ZEND_PRE_INC
Definition zend_vm_opcodes.h:120
ZEND_DEFINED
#define ZEND_DEFINED
Definition zend_vm_opcodes.h:206
ZEND_POST_INC_STATIC_PROP
#define ZEND_POST_INC_STATIC_PROP
Definition zend_vm_opcodes.h:126
ZEND_POST_INC
#define ZEND_POST_INC
Definition zend_vm_opcodes.h:122
ZEND_PRE_DEC
#define ZEND_PRE_DEC
Definition zend_vm_opcodes.h:121
ZEND_BW_XOR
#define ZEND_BW_XOR
Definition zend_vm_opcodes.h:97
ZEND_IS_NOT_EQUAL
#define ZEND_IS_NOT_EQUAL
Definition zend_vm_opcodes.h:105
ZEND_IS_NOT_IDENTICAL
#define ZEND_IS_NOT_IDENTICAL
Definition zend_vm_opcodes.h:103
ZEND_DO_UCALL
#define ZEND_DO_UCALL
Definition zend_vm_opcodes.h:214
ZEND_INSTANCEOF
#define ZEND_INSTANCEOF
Definition zend_vm_opcodes.h:222
ZEND_ROPE_ADD
#define ZEND_ROPE_ADD
Definition zend_vm_opcodes.h:140
ZEND_DIV
#define ZEND_DIV
Definition zend_vm_opcodes.h:90
ZEND_POST_DEC_OBJ
#define ZEND_POST_DEC_OBJ
Definition zend_vm_opcodes.h:219
ZEND_CONCAT
#define ZEND_CONCAT
Definition zend_vm_opcodes.h:94
ZEND_FAST_CONCAT
#define ZEND_FAST_CONCAT
Definition zend_vm_opcodes.h:138
ZEND_MATCH
#define ZEND_MATCH
Definition zend_vm_opcodes.h:279
ZEND_BW_OR
#define ZEND_BW_OR
Definition zend_vm_opcodes.h:95
ZEND_ISSET_ISEMPTY_PROP_OBJ
#define ZEND_ISSET_ISEMPTY_PROP_OBJ
Definition zend_vm_opcodes.h:232
ZEND_JMPNZ_EX
#define ZEND_JMPNZ_EX
Definition zend_vm_opcodes.h:132
ZEND_DO_FCALL
#define ZEND_DO_FCALL
Definition zend_vm_opcodes.h:145
ZEND_ADD_ARRAY_ELEMENT
#define ZEND_ADD_ARRAY_ELEMENT
Definition zend_vm_opcodes.h:157
ZEND_ISSET_ISEMPTY_STATIC_PROP
#define ZEND_ISSET_ISEMPTY_STATIC_PROP
Definition zend_vm_opcodes.h:264
ZEND_IN_ARRAY
#define ZEND_IN_ARRAY
Definition zend_vm_opcodes.h:273
ZEND_ASSIGN_STATIC_PROP
#define ZEND_ASSIGN_STATIC_PROP
Definition zend_vm_opcodes.h:111
ZEND_IS_EQUAL
#define ZEND_IS_EQUAL
Definition zend_vm_opcodes.h:104
ZEND_IS_SMALLER_OR_EQUAL
#define ZEND_IS_SMALLER_OR_EQUAL
Definition zend_vm_opcodes.h:107
ZEND_POST_DEC
#define ZEND_POST_DEC
Definition zend_vm_opcodes.h:123
ZEND_POST_DEC_STATIC_PROP
#define ZEND_POST_DEC_STATIC_PROP
Definition zend_vm_opcodes.h:127
ZEND_BOOL
#define ZEND_BOOL
Definition zend_vm_opcodes.h:137
ZEND_PRE_INC_STATIC_PROP
#define ZEND_PRE_INC_STATIC_PROP
Definition zend_vm_opcodes.h:124
ZEND_STRLEN
#define ZEND_STRLEN
Definition zend_vm_opcodes.h:205
ZEND_MUL
#define ZEND_MUL
Definition zend_vm_opcodes.h:89
ZEND_CASE_STRICT
#define ZEND_CASE_STRICT
Definition zend_vm_opcodes.h:280
ZEND_ROPE_END
#define ZEND_ROPE_END
Definition zend_vm_opcodes.h:141
ZEND_FAST_CALL
#define ZEND_FAST_CALL
Definition zend_vm_opcodes.h:246
ZEND_COPY_TMP
#define ZEND_COPY_TMP
Definition zend_vm_opcodes.h:251
ZEND_DO_ICALL
#define ZEND_DO_ICALL
Definition zend_vm_opcodes.h:213
ZEND_DECLARE_LAMBDA_FUNCTION
#define ZEND_DECLARE_LAMBDA_FUNCTION
Definition zend_vm_opcodes.h:226
ZEND_JMP_NULL
#define ZEND_JMP_NULL
Definition zend_vm_opcodes.h:282
ZEND_BW_NOT
#define ZEND_BW_NOT
Definition zend_vm_opcodes.h:99
ZEND_FETCH_OBJ_R
#define ZEND_FETCH_OBJ_R
Definition zend_vm_opcodes.h:166
ZEND_ISSET_ISEMPTY_DIM_OBJ
#define ZEND_ISSET_ISEMPTY_DIM_OBJ
Definition zend_vm_opcodes.h:199
ZEND_ISSET_ISEMPTY_VAR
#define ZEND_ISSET_ISEMPTY_VAR
Definition zend_vm_opcodes.h:198
ZEND_BIND_INIT_STATIC_OR_JMP
#define ZEND_BIND_INIT_STATIC_OR_JMP
Definition zend_vm_opcodes.h:287
ZEND_BW_AND
#define ZEND_BW_AND
Definition zend_vm_opcodes.h:96
ZEND_GENERATOR_RETURN
#define ZEND_GENERATOR_RETURN
Definition zend_vm_opcodes.h:245
ZEND_ADD_ARRAY_UNPACK
#define ZEND_ADD_ARRAY_UNPACK
Definition zend_vm_opcodes.h:231
ZEND_ARRAY_KEY_EXISTS
#define ZEND_ARRAY_KEY_EXISTS
Definition zend_vm_opcodes.h:278
ZEND_JMP
#define ZEND_JMP
Definition zend_vm_opcodes.h:128
ZEND_FREE
#define ZEND_FREE
Definition zend_vm_opcodes.h:155
ZEND_FE_RESET_R
#define ZEND_FE_RESET_R
Definition zend_vm_opcodes.h:162
ZEND_JMP_FRAMELESS
#define ZEND_JMP_FRAMELESS
Definition zend_vm_opcodes.h:292
ZEND_ASSIGN_OBJ
#define ZEND_ASSIGN_OBJ
Definition zend_vm_opcodes.h:110
ZEND_ASSIGN_OBJ_OP
#define ZEND_ASSIGN_OBJ_OP
Definition zend_vm_opcodes.h:114
ZEND_ASSIGN
#define ZEND_ASSIGN
Definition zend_vm_opcodes.h:108
ZEND_ECHO
#define ZEND_ECHO
Definition zend_vm_opcodes.h:220
ZEND_SR
#define ZEND_SR
Definition zend_vm_opcodes.h:93
ZEND_FETCH_CLASS_CONSTANT
#define ZEND_FETCH_CLASS_CONSTANT
Definition zend_vm_opcodes.h:265
ZEND_TYPE_CHECK
#define ZEND_TYPE_CHECK
Definition zend_vm_opcodes.h:207
ZEND_POST_INC_OBJ
#define ZEND_POST_INC_OBJ
Definition zend_vm_opcodes.h:218
ZEND_FETCH_DIM_R
#define ZEND_FETCH_DIM_R
Definition zend_vm_opcodes.h:165
ZEND_DO_FCALL_BY_NAME
#define ZEND_DO_FCALL_BY_NAME
Definition zend_vm_opcodes.h:215
ZEND_JMPNZ
#define ZEND_JMPNZ
Definition zend_vm_opcodes.h:130
ZEND_CAST
#define ZEND_CAST
Definition zend_vm_opcodes.h:136
ZEND_QM_ASSIGN
#define ZEND_QM_ASSIGN
Definition zend_vm_opcodes.h:117
ZEND_MOD
#define ZEND_MOD
Definition zend_vm_opcodes.h:91
ZEND_CATCH
#define ZEND_CATCH
Definition zend_vm_opcodes.h:191
ZEND_ADD
#define ZEND_ADD
Definition zend_vm_opcodes.h:87
ZEND_COALESCE
#define ZEND_COALESCE
Definition zend_vm_opcodes.h:253
ZEND_ASSIGN_OP
#define ZEND_ASSIGN_OP
Definition zend_vm_opcodes.h:112
ZEND_MATCH_ERROR
#define ZEND_MATCH_ERROR
Definition zend_vm_opcodes.h:281
ZEND_FAST_RET
#define ZEND_FAST_RET
Definition zend_vm_opcodes.h:247
ZEND_CASE
#define ZEND_CASE
Definition zend_vm_opcodes.h:133