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_cfg.h"
29 #include "zend_func_info.h"
30 #include "zend_call_graph.h"
31 #include "zend_inference.h"
32 #include "zend_dump.h"
33 #include "php.h"
34 #include "zend_observer.h"
35
36 #ifndef ZEND_OPTIMIZER_MAX_REGISTERED_PASSES
37 # define ZEND_OPTIMIZER_MAX_REGISTERED_PASSES 32
38 #endif
39
40 struct {
41 zend_optimizer_pass_t pass[ZEND_OPTIMIZER_MAX_REGISTERED_PASSES];
42 int last;
43 } zend_optimizer_registered_passes = {{NULL}, 0};
44
zend_optimizer_collect_constant(zend_optimizer_ctx * ctx,zval * name,zval * value)45 void zend_optimizer_collect_constant(zend_optimizer_ctx *ctx, zval *name, zval* value)
46 {
47 if (!ctx->constants) {
48 ctx->constants = zend_arena_alloc(&ctx->arena, sizeof(HashTable));
49 zend_hash_init(ctx->constants, 16, NULL, zval_ptr_dtor_nogc, 0);
50 }
51
52 if (zend_hash_add(ctx->constants, Z_STR_P(name), value)) {
53 Z_TRY_ADDREF_P(value);
54 }
55 }
56
zend_optimizer_eval_binary_op(zval * result,uint8_t opcode,zval * op1,zval * op2)57 zend_result zend_optimizer_eval_binary_op(zval *result, uint8_t opcode, zval *op1, zval *op2) /* {{{ */
58 {
59 if (zend_binary_op_produces_error(opcode, op1, op2)) {
60 return FAILURE;
61 }
62
63 binary_op_type binary_op = get_binary_op(opcode);
64 return binary_op(result, op1, op2);
65 }
66 /* }}} */
67
zend_optimizer_eval_unary_op(zval * result,uint8_t opcode,zval * op1)68 zend_result zend_optimizer_eval_unary_op(zval *result, uint8_t opcode, zval *op1) /* {{{ */
69 {
70 unary_op_type unary_op = get_unary_op(opcode);
71
72 if (unary_op) {
73 if (zend_unary_op_produces_error(opcode, op1)) {
74 return FAILURE;
75 }
76 return unary_op(result, op1);
77 } else { /* ZEND_BOOL */
78 ZVAL_BOOL(result, zend_is_true(op1));
79 return SUCCESS;
80 }
81 }
82 /* }}} */
83
zend_optimizer_eval_cast(zval * result,uint32_t type,zval * op1)84 zend_result zend_optimizer_eval_cast(zval *result, uint32_t type, zval *op1) /* {{{ */
85 {
86 switch (type) {
87 case IS_NULL:
88 ZVAL_NULL(result);
89 return SUCCESS;
90 case _IS_BOOL:
91 ZVAL_BOOL(result, zval_is_true(op1));
92 return SUCCESS;
93 case IS_LONG:
94 ZVAL_LONG(result, zval_get_long(op1));
95 return SUCCESS;
96 case IS_DOUBLE:
97 ZVAL_DOUBLE(result, zval_get_double(op1));
98 return SUCCESS;
99 case IS_STRING:
100 /* Conversion from double to string takes into account run-time
101 'precision' setting and cannot be evaluated at compile-time */
102 if (Z_TYPE_P(op1) != IS_ARRAY && Z_TYPE_P(op1) != IS_DOUBLE) {
103 ZVAL_STR(result, zval_get_string(op1));
104 return SUCCESS;
105 }
106 break;
107 case IS_ARRAY:
108 ZVAL_COPY(result, op1);
109 convert_to_array(result);
110 return SUCCESS;
111 }
112 return FAILURE;
113 }
114 /* }}} */
115
zend_optimizer_eval_strlen(zval * result,const zval * op1)116 zend_result zend_optimizer_eval_strlen(zval *result, const zval *op1) /* {{{ */
117 {
118 if (Z_TYPE_P(op1) != IS_STRING) {
119 return FAILURE;
120 }
121 ZVAL_LONG(result, Z_STRLEN_P(op1));
122 return SUCCESS;
123 }
124 /* }}} */
125
zend_optimizer_eval_special_func_call(zval * result,zend_string * name,zend_string * arg)126 zend_result zend_optimizer_eval_special_func_call(
127 zval *result, zend_string *name, zend_string *arg) {
128 if (zend_string_equals_literal(name, "function_exists") ||
129 zend_string_equals_literal(name, "is_callable")) {
130 zend_string *lc_name = zend_string_tolower(arg);
131 zend_internal_function *func = zend_hash_find_ptr(EG(function_table), lc_name);
132 zend_string_release_ex(lc_name, 0);
133
134 if (func && func->type == ZEND_INTERNAL_FUNCTION
135 && func->module->type == MODULE_PERSISTENT
136 #ifdef ZEND_WIN32
137 && func->module->handle == NULL
138 #endif
139 ) {
140 ZVAL_TRUE(result);
141 return SUCCESS;
142 }
143 return FAILURE;
144 }
145 if (zend_string_equals_literal(name, "extension_loaded")) {
146 zend_string *lc_name = zend_string_tolower(arg);
147 zend_module_entry *m = zend_hash_find_ptr(&module_registry, lc_name);
148 zend_string_release_ex(lc_name, 0);
149
150 if (!m) {
151 if (PG(enable_dl)) {
152 return FAILURE;
153 }
154 ZVAL_FALSE(result);
155 return SUCCESS;
156 }
157
158 if (m->type == MODULE_PERSISTENT
159 #ifdef ZEND_WIN32
160 && m->handle == NULL
161 #endif
162 ) {
163 ZVAL_TRUE(result);
164 return SUCCESS;
165 }
166 return FAILURE;
167 }
168 if (zend_string_equals_literal(name, "constant")) {
169 return zend_optimizer_get_persistent_constant(arg, result, 1) ? SUCCESS : FAILURE;
170 }
171 if (zend_string_equals_literal(name, "dirname")) {
172 if (!IS_ABSOLUTE_PATH(ZSTR_VAL(arg), ZSTR_LEN(arg))) {
173 return FAILURE;
174 }
175
176 zend_string *dirname = zend_string_init(ZSTR_VAL(arg), ZSTR_LEN(arg), 0);
177 ZSTR_LEN(dirname) = zend_dirname(ZSTR_VAL(dirname), ZSTR_LEN(dirname));
178 if (IS_ABSOLUTE_PATH(ZSTR_VAL(dirname), ZSTR_LEN(dirname))) {
179 ZVAL_STR(result, dirname);
180 return SUCCESS;
181 }
182 zend_string_release_ex(dirname, 0);
183 return FAILURE;
184 }
185 if (zend_string_equals_literal(name, "ini_get")) {
186 zend_ini_entry *ini_entry = zend_hash_find_ptr(EG(ini_directives), arg);
187 if (!ini_entry) {
188 if (PG(enable_dl)) {
189 return FAILURE;
190 }
191 ZVAL_FALSE(result);
192 } else if (ini_entry->modifiable != ZEND_INI_SYSTEM) {
193 return FAILURE;
194 } else if (ini_entry->value) {
195 ZVAL_STR_COPY(result, ini_entry->value);
196 } else {
197 ZVAL_EMPTY_STRING(result);
198 }
199 return SUCCESS;
200 }
201 return FAILURE;
202 }
203
zend_optimizer_get_collected_constant(HashTable * constants,zval * name,zval * value)204 bool zend_optimizer_get_collected_constant(HashTable *constants, zval *name, zval* value)
205 {
206 zval *val;
207
208 if ((val = zend_hash_find(constants, Z_STR_P(name))) != NULL) {
209 ZVAL_COPY(value, val);
210 return 1;
211 }
212 return 0;
213 }
214
zend_optimizer_convert_to_free_op1(zend_op_array * op_array,zend_op * opline)215 void zend_optimizer_convert_to_free_op1(zend_op_array *op_array, zend_op *opline)
216 {
217 if (opline->op1_type == IS_CV) {
218 opline->opcode = ZEND_CHECK_VAR;
219 SET_UNUSED(opline->op2);
220 SET_UNUSED(opline->result);
221 opline->extended_value = 0;
222 } else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
223 opline->opcode = ZEND_FREE;
224 SET_UNUSED(opline->op2);
225 SET_UNUSED(opline->result);
226 opline->extended_value = 0;
227 } else {
228 ZEND_ASSERT(opline->op1_type == IS_CONST);
229 literal_dtor(&ZEND_OP1_LITERAL(opline));
230 MAKE_NOP(opline);
231 }
232 }
233
zend_optimizer_add_literal(zend_op_array * op_array,const zval * zv)234 int zend_optimizer_add_literal(zend_op_array *op_array, const zval *zv)
235 {
236 int i = op_array->last_literal;
237 op_array->last_literal++;
238 op_array->literals = (zval*)erealloc(op_array->literals, op_array->last_literal * sizeof(zval));
239 ZVAL_COPY_VALUE(&op_array->literals[i], zv);
240 Z_EXTRA(op_array->literals[i]) = 0;
241 return i;
242 }
243
zend_optimizer_add_literal_string(zend_op_array * op_array,zend_string * str)244 static inline int zend_optimizer_add_literal_string(zend_op_array *op_array, zend_string *str) {
245 zval zv;
246 ZVAL_STR(&zv, str);
247 zend_string_hash_val(str);
248 return zend_optimizer_add_literal(op_array, &zv);
249 }
250
drop_leading_backslash(zval * val)251 static inline void drop_leading_backslash(zval *val) {
252 if (Z_STRVAL_P(val)[0] == '\\') {
253 zend_string *str = zend_string_init(Z_STRVAL_P(val) + 1, Z_STRLEN_P(val) - 1, 0);
254 zval_ptr_dtor_nogc(val);
255 ZVAL_STR(val, str);
256 }
257 }
258
alloc_cache_slots(zend_op_array * op_array,uint32_t num)259 static inline uint32_t alloc_cache_slots(zend_op_array *op_array, uint32_t num) {
260 uint32_t ret = op_array->cache_size;
261 op_array->cache_size += num * sizeof(void *);
262 return ret;
263 }
264
265 #define REQUIRES_STRING(val) do { \
266 if (Z_TYPE_P(val) != IS_STRING) { \
267 return 0; \
268 } \
269 } while (0)
270
271 #define TO_STRING_NOWARN(val) do { \
272 if (Z_TYPE_P(val) >= IS_ARRAY) { \
273 return 0; \
274 } \
275 convert_to_string(val); \
276 } while (0)
277
zend_optimizer_update_op1_const(zend_op_array * op_array,zend_op * opline,zval * val)278 bool zend_optimizer_update_op1_const(zend_op_array *op_array,
279 zend_op *opline,
280 zval *val)
281 {
282 switch (opline->opcode) {
283 case ZEND_OP_DATA:
284 switch ((opline-1)->opcode) {
285 case ZEND_ASSIGN_OBJ_REF:
286 case ZEND_ASSIGN_STATIC_PROP_REF:
287 return 0;
288 }
289 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
290 break;
291 case ZEND_FREE:
292 case ZEND_CHECK_VAR:
293 MAKE_NOP(opline);
294 zval_ptr_dtor_nogc(val);
295 return 1;
296 case ZEND_SEND_VAR_EX:
297 case ZEND_SEND_FUNC_ARG:
298 case ZEND_FETCH_DIM_W:
299 case ZEND_FETCH_DIM_RW:
300 case ZEND_FETCH_DIM_FUNC_ARG:
301 case ZEND_FETCH_DIM_UNSET:
302 case ZEND_FETCH_LIST_W:
303 case ZEND_ASSIGN_DIM:
304 case ZEND_RETURN_BY_REF:
305 case ZEND_INSTANCEOF:
306 case ZEND_MAKE_REF:
307 case ZEND_SEPARATE:
308 case ZEND_SEND_VAR_NO_REF:
309 case ZEND_SEND_VAR_NO_REF_EX:
310 return 0;
311 case ZEND_CATCH:
312 REQUIRES_STRING(val);
313 drop_leading_backslash(val);
314 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
315 opline->extended_value = alloc_cache_slots(op_array, 1) | (opline->extended_value & ZEND_LAST_CATCH);
316 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
317 break;
318 case ZEND_DEFINED:
319 REQUIRES_STRING(val);
320 drop_leading_backslash(val);
321 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
322 opline->extended_value = alloc_cache_slots(op_array, 1);
323 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
324 break;
325 case ZEND_NEW:
326 REQUIRES_STRING(val);
327 drop_leading_backslash(val);
328 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
329 opline->op2.num = alloc_cache_slots(op_array, 1);
330 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
331 break;
332 case ZEND_INIT_STATIC_METHOD_CALL:
333 REQUIRES_STRING(val);
334 drop_leading_backslash(val);
335 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
336 if (opline->op2_type != IS_CONST) {
337 opline->result.num = alloc_cache_slots(op_array, 1);
338 }
339 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
340 break;
341 case ZEND_FETCH_CLASS_CONSTANT:
342 REQUIRES_STRING(val);
343 drop_leading_backslash(val);
344 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
345 if (opline->op2_type != IS_CONST) {
346 opline->extended_value = alloc_cache_slots(op_array, 1);
347 }
348 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
349 break;
350 case ZEND_ASSIGN_OP:
351 case ZEND_ASSIGN_DIM_OP:
352 case ZEND_ASSIGN_OBJ_OP:
353 break;
354 case ZEND_ASSIGN_STATIC_PROP_OP:
355 case ZEND_ASSIGN_STATIC_PROP:
356 case ZEND_ASSIGN_STATIC_PROP_REF:
357 case ZEND_FETCH_STATIC_PROP_R:
358 case ZEND_FETCH_STATIC_PROP_W:
359 case ZEND_FETCH_STATIC_PROP_RW:
360 case ZEND_FETCH_STATIC_PROP_IS:
361 case ZEND_FETCH_STATIC_PROP_UNSET:
362 case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
363 case ZEND_UNSET_STATIC_PROP:
364 case ZEND_ISSET_ISEMPTY_STATIC_PROP:
365 case ZEND_PRE_INC_STATIC_PROP:
366 case ZEND_PRE_DEC_STATIC_PROP:
367 case ZEND_POST_INC_STATIC_PROP:
368 case ZEND_POST_DEC_STATIC_PROP:
369 TO_STRING_NOWARN(val);
370 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
371 if (opline->op2_type == IS_CONST && (opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) + sizeof(void*) == op_array->cache_size) {
372 op_array->cache_size += sizeof(void *);
373 } else {
374 opline->extended_value = alloc_cache_slots(op_array, 3) | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
375 }
376 break;
377 case ZEND_SEND_VAR:
378 opline->opcode = ZEND_SEND_VAL;
379 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
380 break;
381 case ZEND_CASE:
382 opline->opcode = ZEND_IS_EQUAL;
383 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
384 break;
385 case ZEND_CASE_STRICT:
386 opline->opcode = ZEND_IS_IDENTICAL;
387 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
388 break;
389 case ZEND_VERIFY_RETURN_TYPE:
390 /* This would require a non-local change.
391 * zend_optimizer_replace_by_const() supports this. */
392 return 0;
393 case ZEND_COPY_TMP:
394 case ZEND_FETCH_CLASS_NAME:
395 return 0;
396 case ZEND_ECHO:
397 {
398 zval zv;
399 if (Z_TYPE_P(val) != IS_STRING && zend_optimizer_eval_cast(&zv, IS_STRING, val) == SUCCESS) {
400 zval_ptr_dtor_nogc(val);
401 val = &zv;
402 }
403 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
404 if (Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val) == 0) {
405 MAKE_NOP(opline);
406 return 1;
407 }
408 /* TODO: In a subsequent pass, *after* this step and compacting nops, combine consecutive ZEND_ECHOs using the block information from ssa->cfg */
409 /* (e.g. for ext/opcache/tests/opt/sccp_010.phpt) */
410 break;
411 }
412 case ZEND_CONCAT:
413 case ZEND_FAST_CONCAT:
414 case ZEND_FETCH_R:
415 case ZEND_FETCH_W:
416 case ZEND_FETCH_RW:
417 case ZEND_FETCH_IS:
418 case ZEND_FETCH_UNSET:
419 case ZEND_FETCH_FUNC_ARG:
420 case ZEND_ISSET_ISEMPTY_VAR:
421 case ZEND_UNSET_VAR:
422 TO_STRING_NOWARN(val);
423 if (opline->opcode == ZEND_CONCAT && opline->op2_type == IS_CONST) {
424 opline->opcode = ZEND_FAST_CONCAT;
425 }
426 ZEND_FALLTHROUGH;
427 default:
428 opline->op1.constant = zend_optimizer_add_literal(op_array, val);
429 break;
430 }
431
432 opline->op1_type = IS_CONST;
433 if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
434 zend_string_hash_val(Z_STR(ZEND_OP1_LITERAL(opline)));
435 }
436 return 1;
437 }
438
zend_optimizer_update_op2_const(zend_op_array * op_array,zend_op * opline,zval * val)439 bool zend_optimizer_update_op2_const(zend_op_array *op_array,
440 zend_op *opline,
441 zval *val)
442 {
443 zval tmp;
444
445 switch (opline->opcode) {
446 case ZEND_ASSIGN_REF:
447 case ZEND_FAST_CALL:
448 return 0;
449 case ZEND_FETCH_CLASS:
450 case ZEND_INSTANCEOF:
451 REQUIRES_STRING(val);
452 drop_leading_backslash(val);
453 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
454 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
455 opline->extended_value = alloc_cache_slots(op_array, 1);
456 break;
457 case ZEND_INIT_FCALL_BY_NAME:
458 REQUIRES_STRING(val);
459 drop_leading_backslash(val);
460 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
461 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
462 opline->result.num = alloc_cache_slots(op_array, 1);
463 break;
464 case ZEND_ASSIGN_STATIC_PROP:
465 case ZEND_ASSIGN_STATIC_PROP_REF:
466 case ZEND_FETCH_STATIC_PROP_R:
467 case ZEND_FETCH_STATIC_PROP_W:
468 case ZEND_FETCH_STATIC_PROP_RW:
469 case ZEND_FETCH_STATIC_PROP_IS:
470 case ZEND_FETCH_STATIC_PROP_UNSET:
471 case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
472 case ZEND_UNSET_STATIC_PROP:
473 case ZEND_ISSET_ISEMPTY_STATIC_PROP:
474 case ZEND_PRE_INC_STATIC_PROP:
475 case ZEND_PRE_DEC_STATIC_PROP:
476 case ZEND_POST_INC_STATIC_PROP:
477 case ZEND_POST_DEC_STATIC_PROP:
478 case ZEND_ASSIGN_STATIC_PROP_OP:
479 REQUIRES_STRING(val);
480 drop_leading_backslash(val);
481 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
482 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
483 if (opline->op1_type != IS_CONST) {
484 opline->extended_value = alloc_cache_slots(op_array, 1) | (opline->extended_value & (ZEND_RETURNS_FUNCTION|ZEND_ISEMPTY|ZEND_FETCH_OBJ_FLAGS));
485 }
486 break;
487 case ZEND_INIT_FCALL:
488 REQUIRES_STRING(val);
489 if (Z_REFCOUNT_P(val) == 1) {
490 zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
491 } else {
492 ZVAL_STR(&tmp, zend_string_tolower(Z_STR_P(val)));
493 zval_ptr_dtor_nogc(val);
494 val = &tmp;
495 }
496 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
497 opline->result.num = alloc_cache_slots(op_array, 1);
498 break;
499 case ZEND_INIT_DYNAMIC_CALL:
500 if (Z_TYPE_P(val) == IS_STRING) {
501 if (zend_memrchr(Z_STRVAL_P(val), ':', Z_STRLEN_P(val))) {
502 return 0;
503 }
504
505 if (zend_optimizer_classify_function(Z_STR_P(val), opline->extended_value)) {
506 /* Dynamic call to various special functions must stay dynamic,
507 * otherwise would drop a warning */
508 return 0;
509 }
510
511 opline->opcode = ZEND_INIT_FCALL_BY_NAME;
512 drop_leading_backslash(val);
513 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
514 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
515 opline->result.num = alloc_cache_slots(op_array, 1);
516 } else {
517 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
518 }
519 break;
520 case ZEND_INIT_METHOD_CALL:
521 REQUIRES_STRING(val);
522 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
523 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
524 opline->result.num = alloc_cache_slots(op_array, 2);
525 break;
526 case ZEND_INIT_STATIC_METHOD_CALL:
527 REQUIRES_STRING(val);
528 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
529 zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
530 if (opline->op1_type != IS_CONST) {
531 opline->result.num = alloc_cache_slots(op_array, 2);
532 }
533 break;
534 case ZEND_ASSIGN_OBJ:
535 case ZEND_ASSIGN_OBJ_REF:
536 case ZEND_FETCH_OBJ_R:
537 case ZEND_FETCH_OBJ_W:
538 case ZEND_FETCH_OBJ_RW:
539 case ZEND_FETCH_OBJ_IS:
540 case ZEND_FETCH_OBJ_UNSET:
541 case ZEND_FETCH_OBJ_FUNC_ARG:
542 case ZEND_UNSET_OBJ:
543 case ZEND_PRE_INC_OBJ:
544 case ZEND_PRE_DEC_OBJ:
545 case ZEND_POST_INC_OBJ:
546 case ZEND_POST_DEC_OBJ:
547 TO_STRING_NOWARN(val);
548 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
549 opline->extended_value = alloc_cache_slots(op_array, 3);
550 break;
551 case ZEND_ASSIGN_OBJ_OP:
552 TO_STRING_NOWARN(val);
553 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
554 ZEND_ASSERT((opline + 1)->opcode == ZEND_OP_DATA);
555 (opline + 1)->extended_value = alloc_cache_slots(op_array, 3);
556 break;
557 case ZEND_ISSET_ISEMPTY_PROP_OBJ:
558 TO_STRING_NOWARN(val);
559 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
560 opline->extended_value = alloc_cache_slots(op_array, 3) | (opline->extended_value & ZEND_ISEMPTY);
561 break;
562 case ZEND_ASSIGN_DIM_OP:
563 case ZEND_ISSET_ISEMPTY_DIM_OBJ:
564 case ZEND_ASSIGN_DIM:
565 case ZEND_UNSET_DIM:
566 case ZEND_FETCH_DIM_R:
567 case ZEND_FETCH_DIM_W:
568 case ZEND_FETCH_DIM_RW:
569 case ZEND_FETCH_DIM_IS:
570 case ZEND_FETCH_DIM_FUNC_ARG:
571 case ZEND_FETCH_DIM_UNSET:
572 case ZEND_FETCH_LIST_R:
573 case ZEND_FETCH_LIST_W:
574 if (Z_TYPE_P(val) == IS_STRING) {
575 zend_ulong index;
576
577 if (ZEND_HANDLE_NUMERIC(Z_STR_P(val), index)) {
578 ZVAL_LONG(&tmp, index);
579 opline->op2.constant = zend_optimizer_add_literal(op_array, &tmp);
580 zend_string_hash_val(Z_STR_P(val));
581 zend_optimizer_add_literal(op_array, val);
582 Z_EXTRA(op_array->literals[opline->op2.constant]) = ZEND_EXTRA_VALUE;
583 break;
584 }
585 }
586 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
587 break;
588 case ZEND_ADD_ARRAY_ELEMENT:
589 case ZEND_INIT_ARRAY:
590 if (Z_TYPE_P(val) == IS_STRING) {
591 zend_ulong index;
592 if (ZEND_HANDLE_NUMERIC(Z_STR_P(val), index)) {
593 zval_ptr_dtor_nogc(val);
594 ZVAL_LONG(val, index);
595 }
596 }
597 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
598 break;
599 case ZEND_ROPE_INIT:
600 case ZEND_ROPE_ADD:
601 case ZEND_ROPE_END:
602 case ZEND_CONCAT:
603 case ZEND_FAST_CONCAT:
604 TO_STRING_NOWARN(val);
605 if (opline->opcode == ZEND_CONCAT && opline->op1_type == IS_CONST) {
606 opline->opcode = ZEND_FAST_CONCAT;
607 }
608 ZEND_FALLTHROUGH;
609 default:
610 opline->op2.constant = zend_optimizer_add_literal(op_array, val);
611 break;
612 }
613
614 opline->op2_type = IS_CONST;
615 if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
616 zend_string_hash_val(Z_STR(ZEND_OP2_LITERAL(opline)));
617 }
618 return 1;
619 }
620
zend_optimizer_replace_by_const(zend_op_array * op_array,zend_op * opline,uint8_t type,uint32_t var,zval * val)621 bool zend_optimizer_replace_by_const(zend_op_array *op_array,
622 zend_op *opline,
623 uint8_t type,
624 uint32_t var,
625 zval *val)
626 {
627 zend_op *end = op_array->opcodes + op_array->last;
628
629 while (opline < end) {
630 if (opline->op1_type == type &&
631 opline->op1.var == var) {
632 switch (opline->opcode) {
633 /* In most cases IS_TMP_VAR operand may be used only once.
634 * The operands are usually destroyed by the opcode handler.
635 * However, there are some exception which keep the operand alive. In that case
636 * we want to try to replace all uses of the temporary.
637 */
638 case ZEND_FETCH_LIST_R:
639 case ZEND_CASE:
640 case ZEND_CASE_STRICT:
641 case ZEND_SWITCH_LONG:
642 case ZEND_SWITCH_STRING:
643 case ZEND_MATCH:
644 case ZEND_JMP_NULL: {
645 zend_op *end = op_array->opcodes + op_array->last;
646 while (opline < end) {
647 if (opline->op1_type == type && opline->op1.var == var) {
648 /* If this opcode doesn't keep the operand alive, we're done. Check
649 * this early, because op replacement may modify the opline. */
650 bool is_last = opline->opcode != ZEND_FETCH_LIST_R
651 && opline->opcode != ZEND_CASE
652 && opline->opcode != ZEND_CASE_STRICT
653 && opline->opcode != ZEND_SWITCH_LONG
654 && opline->opcode != ZEND_SWITCH_STRING
655 && opline->opcode != ZEND_MATCH
656 && opline->opcode != ZEND_JMP_NULL
657 && (opline->opcode != ZEND_FREE
658 || opline->extended_value != ZEND_FREE_ON_RETURN);
659
660 Z_TRY_ADDREF_P(val);
661 if (!zend_optimizer_update_op1_const(op_array, opline, val)) {
662 zval_ptr_dtor(val);
663 return 0;
664 }
665 if (is_last) {
666 break;
667 }
668 }
669 opline++;
670 }
671 zval_ptr_dtor_nogc(val);
672 return 1;
673 }
674 case ZEND_VERIFY_RETURN_TYPE: {
675 zend_arg_info *ret_info = op_array->arg_info - 1;
676 if (!ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(val))
677 || (op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
678 return 0;
679 }
680 MAKE_NOP(opline);
681
682 /* zend_handle_loops_and_finally may inserts other oplines */
683 do {
684 ++opline;
685 } while (opline->opcode != ZEND_RETURN && opline->opcode != ZEND_RETURN_BY_REF);
686 ZEND_ASSERT(opline->op1.var == var);
687
688 break;
689 }
690 default:
691 break;
692 }
693 return zend_optimizer_update_op1_const(op_array, opline, val);
694 }
695
696 if (opline->op2_type == type &&
697 opline->op2.var == var) {
698 return zend_optimizer_update_op2_const(op_array, opline, val);
699 }
700 opline++;
701 }
702
703 return 1;
704 }
705
706 /* Update jump offsets after a jump was migrated to another opline */
zend_optimizer_migrate_jump(zend_op_array * op_array,zend_op * new_opline,zend_op * opline)707 void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, zend_op *opline) {
708 switch (new_opline->opcode) {
709 case ZEND_JMP:
710 case ZEND_FAST_CALL:
711 ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op1, ZEND_OP1_JMP_ADDR(opline));
712 break;
713 case ZEND_JMPZ:
714 case ZEND_JMPNZ:
715 case ZEND_JMPZ_EX:
716 case ZEND_JMPNZ_EX:
717 case ZEND_FE_RESET_R:
718 case ZEND_FE_RESET_RW:
719 case ZEND_JMP_SET:
720 case ZEND_COALESCE:
721 case ZEND_ASSERT_CHECK:
722 case ZEND_JMP_NULL:
723 case ZEND_BIND_INIT_STATIC_OR_JMP:
724 ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op2, ZEND_OP2_JMP_ADDR(opline));
725 break;
726 case ZEND_FE_FETCH_R:
727 case ZEND_FE_FETCH_RW:
728 new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
729 break;
730 case ZEND_CATCH:
731 if (!(opline->extended_value & ZEND_LAST_CATCH)) {
732 ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op2, ZEND_OP2_JMP_ADDR(opline));
733 }
734 break;
735 case ZEND_SWITCH_LONG:
736 case ZEND_SWITCH_STRING:
737 case ZEND_MATCH:
738 {
739 HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
740 zval *zv;
741 ZEND_HASH_FOREACH_VAL(jumptable, zv) {
742 Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
743 } ZEND_HASH_FOREACH_END();
744 new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
745 break;
746 }
747 }
748 }
749
750 /* Shift jump offsets based on shiftlist */
zend_optimizer_shift_jump(zend_op_array * op_array,zend_op * opline,uint32_t * shiftlist)751 void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_t *shiftlist) {
752 switch (opline->opcode) {
753 case ZEND_JMP:
754 case ZEND_FAST_CALL:
755 ZEND_SET_OP_JMP_ADDR(opline, opline->op1, ZEND_OP1_JMP_ADDR(opline) - shiftlist[ZEND_OP1_JMP_ADDR(opline) - op_array->opcodes]);
756 break;
757 case ZEND_JMPZ:
758 case ZEND_JMPNZ:
759 case ZEND_JMPZ_EX:
760 case ZEND_JMPNZ_EX:
761 case ZEND_FE_RESET_R:
762 case ZEND_FE_RESET_RW:
763 case ZEND_JMP_SET:
764 case ZEND_COALESCE:
765 case ZEND_ASSERT_CHECK:
766 case ZEND_JMP_NULL:
767 case ZEND_BIND_INIT_STATIC_OR_JMP:
768 ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP2_JMP_ADDR(opline) - shiftlist[ZEND_OP2_JMP_ADDR(opline) - op_array->opcodes]);
769 break;
770 case ZEND_CATCH:
771 if (!(opline->extended_value & ZEND_LAST_CATCH)) {
772 ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP2_JMP_ADDR(opline) - shiftlist[ZEND_OP2_JMP_ADDR(opline) - op_array->opcodes]);
773 }
774 break;
775 case ZEND_FE_FETCH_R:
776 case ZEND_FE_FETCH_RW:
777 opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]);
778 break;
779 case ZEND_SWITCH_LONG:
780 case ZEND_SWITCH_STRING:
781 case ZEND_MATCH:
782 {
783 HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline));
784 zval *zv;
785 ZEND_HASH_FOREACH_VAL(jumptable, zv) {
786 Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))]);
787 } ZEND_HASH_FOREACH_END();
788 opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]);
789 break;
790 }
791 }
792 }
793
zend_optimizer_get_class_entry(const zend_script * script,const zend_op_array * op_array,zend_string * lcname)794 zend_class_entry *zend_optimizer_get_class_entry(
795 const zend_script *script, const zend_op_array *op_array, zend_string *lcname) {
796 zend_class_entry *ce = script ? zend_hash_find_ptr(&script->class_table, lcname) : NULL;
797 if (ce) {
798 return ce;
799 }
800
801 ce = zend_hash_find_ptr(CG(class_table), lcname);
802 if (ce
803 && (ce->type == ZEND_INTERNAL_CLASS
804 || (op_array && ce->info.user.filename == op_array->filename))) {
805 return ce;
806 }
807
808 if (op_array && op_array->scope && zend_string_equals_ci(op_array->scope->name, lcname)) {
809 return op_array->scope;
810 }
811
812 return NULL;
813 }
814
zend_optimizer_get_class_entry_from_op1(const zend_script * script,const zend_op_array * op_array,const zend_op * opline)815 zend_class_entry *zend_optimizer_get_class_entry_from_op1(
816 const zend_script *script, const zend_op_array *op_array, const zend_op *opline) {
817 if (opline->op1_type == IS_CONST) {
818 zval *op1 = CRT_CONSTANT(opline->op1);
819 if (Z_TYPE_P(op1) == IS_STRING) {
820 return zend_optimizer_get_class_entry(script, op_array, Z_STR_P(op1 + 1));
821 }
822 } else if (opline->op1_type == IS_UNUSED && op_array->scope
823 && !(op_array->scope->ce_flags & ZEND_ACC_TRAIT)
824 && (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
825 return op_array->scope;
826 }
827 return NULL;
828 }
829
zend_optimizer_get_called_func(zend_script * script,zend_op_array * op_array,zend_op * opline,bool * is_prototype)830 zend_function *zend_optimizer_get_called_func(
831 zend_script *script, zend_op_array *op_array, zend_op *opline, bool *is_prototype)
832 {
833 *is_prototype = 0;
834 switch (opline->opcode) {
835 case ZEND_INIT_FCALL:
836 {
837 zend_string *function_name = Z_STR_P(CRT_CONSTANT(opline->op2));
838 zend_function *func;
839 if (script && (func = zend_hash_find_ptr(&script->function_table, function_name)) != NULL) {
840 return func;
841 } else if ((func = zend_hash_find_ptr(EG(function_table), function_name)) != NULL) {
842 if (func->type == ZEND_INTERNAL_FUNCTION) {
843 return func;
844 } else if (func->type == ZEND_USER_FUNCTION &&
845 func->op_array.filename &&
846 func->op_array.filename == op_array->filename) {
847 return func;
848 }
849 }
850 break;
851 }
852 case ZEND_INIT_FCALL_BY_NAME:
853 case ZEND_INIT_NS_FCALL_BY_NAME:
854 if (opline->op2_type == IS_CONST && Z_TYPE_P(CRT_CONSTANT(opline->op2)) == IS_STRING) {
855 zval *function_name = CRT_CONSTANT(opline->op2) + 1;
856 zend_function *func;
857 if (script && (func = zend_hash_find_ptr(&script->function_table, Z_STR_P(function_name)))) {
858 return func;
859 } else if ((func = zend_hash_find_ptr(EG(function_table), Z_STR_P(function_name))) != NULL) {
860 if (func->type == ZEND_INTERNAL_FUNCTION) {
861 return func;
862 } else if (func->type == ZEND_USER_FUNCTION &&
863 func->op_array.filename &&
864 func->op_array.filename == op_array->filename) {
865 return func;
866 }
867 }
868 }
869 break;
870 case ZEND_INIT_STATIC_METHOD_CALL:
871 if (opline->op2_type == IS_CONST && Z_TYPE_P(CRT_CONSTANT(opline->op2)) == IS_STRING) {
872 zend_class_entry *ce = zend_optimizer_get_class_entry_from_op1(
873 script, op_array, opline);
874 if (ce) {
875 zend_string *func_name = Z_STR_P(CRT_CONSTANT(opline->op2) + 1);
876 zend_function *fbc = zend_hash_find_ptr(&ce->function_table, func_name);
877 if (fbc) {
878 bool is_public = (fbc->common.fn_flags & ZEND_ACC_PUBLIC) != 0;
879 bool same_scope = fbc->common.scope == op_array->scope;
880 if (is_public || same_scope) {
881 return fbc;
882 }
883 }
884 }
885 }
886 break;
887 case ZEND_INIT_METHOD_CALL:
888 if (opline->op1_type == IS_UNUSED
889 && opline->op2_type == IS_CONST && Z_TYPE_P(CRT_CONSTANT(opline->op2)) == IS_STRING
890 && op_array->scope
891 && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)
892 && !(op_array->scope->ce_flags & ZEND_ACC_TRAIT)) {
893 zend_string *method_name = Z_STR_P(CRT_CONSTANT(opline->op2) + 1);
894 zend_function *fbc = zend_hash_find_ptr(
895 &op_array->scope->function_table, method_name);
896 if (fbc) {
897 bool is_private = (fbc->common.fn_flags & ZEND_ACC_PRIVATE) != 0;
898 if (is_private) {
899 /* Only use private method if in the same scope. We can't even use it
900 * as a prototype, as it may be overridden with changed signature. */
901 bool same_scope = fbc->common.scope == op_array->scope;
902 return same_scope ? fbc : NULL;
903 }
904 /* Prototype methods are potentially overridden. fbc still contains useful type information.
905 * Some optimizations may not be applied, like inlining or inferring the send-mode of superfluous args.
906 * A method cannot be overridden if the class or method is final. */
907 if ((fbc->common.fn_flags & ZEND_ACC_FINAL) == 0 &&
908 (fbc->common.scope->ce_flags & ZEND_ACC_FINAL) == 0) {
909 *is_prototype = true;
910 }
911 return fbc;
912 }
913 }
914 break;
915 case ZEND_NEW:
916 {
917 zend_class_entry *ce = zend_optimizer_get_class_entry_from_op1(
918 script, op_array, opline);
919 if (ce && ce->type == ZEND_USER_CLASS) {
920 return ce->constructor;
921 }
922 break;
923 }
924 }
925 return NULL;
926 }
927
zend_optimizer_classify_function(zend_string * name,uint32_t num_args)928 uint32_t zend_optimizer_classify_function(zend_string *name, uint32_t num_args) {
929 if (zend_string_equals_literal(name, "extract")) {
930 return ZEND_FUNC_INDIRECT_VAR_ACCESS;
931 } else if (zend_string_equals_literal(name, "compact")) {
932 return ZEND_FUNC_INDIRECT_VAR_ACCESS;
933 } else if (zend_string_equals_literal(name, "get_defined_vars")) {
934 return ZEND_FUNC_INDIRECT_VAR_ACCESS;
935 } else if (zend_string_equals_literal(name, "db2_execute")) {
936 return ZEND_FUNC_INDIRECT_VAR_ACCESS;
937 } else if (zend_string_equals_literal(name, "func_num_args")) {
938 return ZEND_FUNC_VARARG;
939 } else if (zend_string_equals_literal(name, "func_get_arg")) {
940 return ZEND_FUNC_VARARG;
941 } else if (zend_string_equals_literal(name, "func_get_args")) {
942 return ZEND_FUNC_VARARG;
943 } else {
944 return 0;
945 }
946 }
947
zend_optimizer_get_loop_var_def(const zend_op_array * op_array,zend_op * free_opline)948 zend_op *zend_optimizer_get_loop_var_def(const zend_op_array *op_array, zend_op *free_opline) {
949 uint32_t var = free_opline->op1.var;
950 ZEND_ASSERT(zend_optimizer_is_loop_var_free(free_opline));
951
952 while (--free_opline >= op_array->opcodes) {
953 if ((free_opline->result_type & (IS_TMP_VAR|IS_VAR)) && free_opline->result.var == var) {
954 return free_opline;
955 }
956 }
957 return NULL;
958 }
959
zend_optimize(zend_op_array * op_array,zend_optimizer_ctx * ctx)960 static void zend_optimize(zend_op_array *op_array,
961 zend_optimizer_ctx *ctx)
962 {
963 if (op_array->type == ZEND_EVAL_CODE) {
964 return;
965 }
966
967 if (ctx->debug_level & ZEND_DUMP_BEFORE_OPTIMIZER) {
968 zend_dump_op_array(op_array, ZEND_DUMP_LIVE_RANGES, "before optimizer", NULL);
969 }
970
971 /* pass 1 (Simple local optimizations)
972 * - persistent constant substitution (true, false, null, etc)
973 * - constant casting (ADD expects numbers, CONCAT strings, etc)
974 * - constant expression evaluation
975 * - optimize constant conditional JMPs
976 * - pre-evaluate constant function calls
977 * - eliminate FETCH $GLOBALS followed by FETCH_DIM/UNSET_DIM/ISSET_ISEMPTY_DIM
978 */
979 if (ZEND_OPTIMIZER_PASS_1 & ctx->optimization_level) {
980 zend_optimizer_pass1(op_array, ctx);
981 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_1) {
982 zend_dump_op_array(op_array, 0, "after pass 1", NULL);
983 }
984 }
985
986 /* pass 3: (Jump optimization)
987 * - optimize series of JMPs
988 */
989 if (ZEND_OPTIMIZER_PASS_3 & ctx->optimization_level) {
990 zend_optimizer_pass3(op_array, ctx);
991 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_3) {
992 zend_dump_op_array(op_array, 0, "after pass 3", NULL);
993 }
994 }
995
996 /* pass 4:
997 * - INIT_FCALL_BY_NAME -> DO_FCALL
998 */
999 if (ZEND_OPTIMIZER_PASS_4 & ctx->optimization_level) {
1000 zend_optimize_func_calls(op_array, ctx);
1001 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_4) {
1002 zend_dump_op_array(op_array, 0, "after pass 4", NULL);
1003 }
1004 }
1005
1006 /* pass 5:
1007 * - CFG optimization
1008 */
1009 if (ZEND_OPTIMIZER_PASS_5 & ctx->optimization_level) {
1010 zend_optimize_cfg(op_array, ctx);
1011 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_5) {
1012 zend_dump_op_array(op_array, 0, "after pass 5", NULL);
1013 }
1014 }
1015
1016 /* pass 6:
1017 * - DFA optimization
1018 */
1019 if ((ZEND_OPTIMIZER_PASS_6 & ctx->optimization_level) &&
1020 !(ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level)) {
1021 zend_optimize_dfa(op_array, ctx);
1022 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_6) {
1023 zend_dump_op_array(op_array, 0, "after pass 6", NULL);
1024 }
1025 }
1026
1027 /* pass 9:
1028 * - Optimize temp variables usage
1029 */
1030 if ((ZEND_OPTIMIZER_PASS_9 & ctx->optimization_level) &&
1031 !(ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level)) {
1032 zend_optimize_temporary_variables(op_array, ctx);
1033 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_9) {
1034 zend_dump_op_array(op_array, 0, "after pass 9", NULL);
1035 }
1036 }
1037
1038 /* pass 10:
1039 * - remove NOPs
1040 */
1041 if (((ZEND_OPTIMIZER_PASS_10|ZEND_OPTIMIZER_PASS_5) & ctx->optimization_level) == ZEND_OPTIMIZER_PASS_10) {
1042 zend_optimizer_nop_removal(op_array, ctx);
1043 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_10) {
1044 zend_dump_op_array(op_array, 0, "after pass 10", NULL);
1045 }
1046 }
1047
1048 /* pass 11:
1049 * - Compact literals table
1050 */
1051 if ((ZEND_OPTIMIZER_PASS_11 & ctx->optimization_level) &&
1052 (!(ZEND_OPTIMIZER_PASS_6 & ctx->optimization_level) ||
1053 !(ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level))) {
1054 zend_optimizer_compact_literals(op_array, ctx);
1055 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_11) {
1056 zend_dump_op_array(op_array, 0, "after pass 11", NULL);
1057 }
1058 }
1059
1060 if ((ZEND_OPTIMIZER_PASS_13 & ctx->optimization_level) &&
1061 (!(ZEND_OPTIMIZER_PASS_6 & ctx->optimization_level) ||
1062 !(ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level))) {
1063 zend_optimizer_compact_vars(op_array);
1064 if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_13) {
1065 zend_dump_op_array(op_array, 0, "after pass 13", NULL);
1066 }
1067 }
1068
1069 if (ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level) {
1070 return;
1071 }
1072
1073 if (ctx->debug_level & ZEND_DUMP_AFTER_OPTIMIZER) {
1074 zend_dump_op_array(op_array, 0, "after optimizer", NULL);
1075 }
1076 }
1077
zend_revert_pass_two(zend_op_array * op_array)1078 static void zend_revert_pass_two(zend_op_array *op_array)
1079 {
1080 zend_op *opline, *end;
1081
1082 ZEND_ASSERT((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) != 0);
1083
1084 opline = op_array->opcodes;
1085 end = opline + op_array->last;
1086 while (opline < end) {
1087 if (opline->op1_type == IS_CONST) {
1088 ZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline, opline->op1);
1089 }
1090 if (opline->op2_type == IS_CONST) {
1091 ZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline, opline->op2);
1092 }
1093 /* reset smart branch flags IS_SMART_BRANCH_JMP[N]Z */
1094 opline->result_type &= (IS_TMP_VAR|IS_VAR|IS_CV|IS_CONST);
1095 opline++;
1096 }
1097 #if !ZEND_USE_ABS_CONST_ADDR
1098 if (op_array->literals) {
1099 zval *literals = emalloc(sizeof(zval) * op_array->last_literal);
1100 memcpy(literals, op_array->literals, sizeof(zval) * op_array->last_literal);
1101 op_array->literals = literals;
1102 }
1103 #endif
1104
1105 op_array->T -= ZEND_OBSERVER_ENABLED;
1106
1107 op_array->fn_flags &= ~ZEND_ACC_DONE_PASS_TWO;
1108 }
1109
zend_redo_pass_two(zend_op_array * op_array)1110 static void zend_redo_pass_two(zend_op_array *op_array)
1111 {
1112 zend_op *opline, *end;
1113 #if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR
1114 zend_op *old_opcodes = op_array->opcodes;
1115 #endif
1116
1117 ZEND_ASSERT((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) == 0);
1118
1119 #if !ZEND_USE_ABS_CONST_ADDR
1120 if (op_array->last_literal) {
1121 op_array->opcodes = (zend_op *) erealloc(op_array->opcodes,
1122 ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) +
1123 sizeof(zval) * op_array->last_literal);
1124 memcpy(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16),
1125 op_array->literals, sizeof(zval) * op_array->last_literal);
1126 efree(op_array->literals);
1127 op_array->literals = (zval*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16));
1128 } else {
1129 if (op_array->literals) {
1130 efree(op_array->literals);
1131 }
1132 op_array->literals = NULL;
1133 }
1134 #endif
1135
1136 op_array->T += ZEND_OBSERVER_ENABLED; // reserve last temporary for observers if enabled
1137
1138 opline = op_array->opcodes;
1139 end = opline + op_array->last;
1140 while (opline < end) {
1141 if (opline->op1_type == IS_CONST) {
1142 ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1);
1143 }
1144 if (opline->op2_type == IS_CONST) {
1145 ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2);
1146 }
1147 /* fix jumps to point to new array */
1148 switch (opline->opcode) {
1149 #if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR
1150 case ZEND_JMP:
1151 case ZEND_FAST_CALL:
1152 opline->op1.jmp_addr = &op_array->opcodes[opline->op1.jmp_addr - old_opcodes];
1153 break;
1154 case ZEND_JMPZ:
1155 case ZEND_JMPNZ:
1156 case ZEND_JMPZ_EX:
1157 case ZEND_JMPNZ_EX:
1158 case ZEND_JMP_SET:
1159 case ZEND_COALESCE:
1160 case ZEND_FE_RESET_R:
1161 case ZEND_FE_RESET_RW:
1162 case ZEND_ASSERT_CHECK:
1163 case ZEND_JMP_NULL:
1164 case ZEND_BIND_INIT_STATIC_OR_JMP:
1165 opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
1166 break;
1167 case ZEND_CATCH:
1168 if (!(opline->extended_value & ZEND_LAST_CATCH)) {
1169 opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
1170 }
1171 break;
1172 case ZEND_FE_FETCH_R:
1173 case ZEND_FE_FETCH_RW:
1174 case ZEND_SWITCH_LONG:
1175 case ZEND_SWITCH_STRING:
1176 case ZEND_MATCH:
1177 /* relative extended_value don't have to be changed */
1178 break;
1179 #endif
1180 case ZEND_IS_IDENTICAL:
1181 case ZEND_IS_NOT_IDENTICAL:
1182 case ZEND_IS_EQUAL:
1183 case ZEND_IS_NOT_EQUAL:
1184 case ZEND_IS_SMALLER:
1185 case ZEND_IS_SMALLER_OR_EQUAL:
1186 case ZEND_CASE:
1187 case ZEND_CASE_STRICT:
1188 case ZEND_ISSET_ISEMPTY_CV:
1189 case ZEND_ISSET_ISEMPTY_VAR:
1190 case ZEND_ISSET_ISEMPTY_DIM_OBJ:
1191 case ZEND_ISSET_ISEMPTY_PROP_OBJ:
1192 case ZEND_ISSET_ISEMPTY_STATIC_PROP:
1193 case ZEND_INSTANCEOF:
1194 case ZEND_TYPE_CHECK:
1195 case ZEND_DEFINED:
1196 case ZEND_IN_ARRAY:
1197 case ZEND_ARRAY_KEY_EXISTS:
1198 if (opline->result_type & IS_TMP_VAR) {
1199 /* reinitialize result_type of smart branch instructions */
1200 if (opline + 1 < end) {
1201 if ((opline+1)->opcode == ZEND_JMPZ
1202 && (opline+1)->op1_type == IS_TMP_VAR
1203 && (opline+1)->op1.var == opline->result.var) {
1204 opline->result_type = IS_SMART_BRANCH_JMPZ | IS_TMP_VAR;
1205 } else if ((opline+1)->opcode == ZEND_JMPNZ
1206 && (opline+1)->op1_type == IS_TMP_VAR
1207 && (opline+1)->op1.var == opline->result.var) {
1208 opline->result_type = IS_SMART_BRANCH_JMPNZ | IS_TMP_VAR;
1209 }
1210 }
1211 }
1212 break;
1213 }
1214 ZEND_VM_SET_OPCODE_HANDLER(opline);
1215 opline++;
1216 }
1217
1218 op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
1219 }
1220
zend_redo_pass_two_ex(zend_op_array * op_array,zend_ssa * ssa)1221 static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa)
1222 {
1223 zend_op *opline, *end;
1224 #if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR
1225 zend_op *old_opcodes = op_array->opcodes;
1226 #endif
1227
1228 ZEND_ASSERT((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) == 0);
1229
1230 #if !ZEND_USE_ABS_CONST_ADDR
1231 if (op_array->last_literal) {
1232 op_array->opcodes = (zend_op *) erealloc(op_array->opcodes,
1233 ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) +
1234 sizeof(zval) * op_array->last_literal);
1235 memcpy(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16),
1236 op_array->literals, sizeof(zval) * op_array->last_literal);
1237 efree(op_array->literals);
1238 op_array->literals = (zval*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16));
1239 } else {
1240 if (op_array->literals) {
1241 efree(op_array->literals);
1242 }
1243 op_array->literals = NULL;
1244 }
1245 #endif
1246
1247 opline = op_array->opcodes;
1248 end = opline + op_array->last;
1249 while (opline < end) {
1250 zend_ssa_op *ssa_op = &ssa->ops[opline - op_array->opcodes];
1251 uint32_t op1_info = opline->op1_type == IS_UNUSED ? 0 : (OP1_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY));
1252 uint32_t op2_info = opline->op1_type == IS_UNUSED ? 0 : (OP2_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY));
1253 uint32_t res_info =
1254 (opline->opcode == ZEND_PRE_INC ||
1255 opline->opcode == ZEND_PRE_DEC ||
1256 opline->opcode == ZEND_POST_INC ||
1257 opline->opcode == ZEND_POST_DEC) ?
1258 ((ssa->ops[opline - op_array->opcodes].op1_def >= 0) ? (OP1_DEF_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY)) : MAY_BE_ANY) :
1259 (opline->result_type == IS_UNUSED ? 0 : (RES_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY)));
1260
1261 if (opline->op1_type == IS_CONST) {
1262 ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1);
1263 }
1264 if (opline->op2_type == IS_CONST) {
1265 ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2);
1266 }
1267
1268 /* fix jumps to point to new array */
1269 switch (opline->opcode) {
1270 #if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR
1271 case ZEND_JMP:
1272 case ZEND_FAST_CALL:
1273 opline->op1.jmp_addr = &op_array->opcodes[opline->op1.jmp_addr - old_opcodes];
1274 break;
1275 case ZEND_JMPZ:
1276 case ZEND_JMPNZ:
1277 case ZEND_JMPZ_EX:
1278 case ZEND_JMPNZ_EX:
1279 case ZEND_JMP_SET:
1280 case ZEND_COALESCE:
1281 case ZEND_FE_RESET_R:
1282 case ZEND_FE_RESET_RW:
1283 case ZEND_ASSERT_CHECK:
1284 case ZEND_JMP_NULL:
1285 case ZEND_BIND_INIT_STATIC_OR_JMP:
1286 opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
1287 break;
1288 case ZEND_CATCH:
1289 if (!(opline->extended_value & ZEND_LAST_CATCH)) {
1290 opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
1291 }
1292 break;
1293 case ZEND_FE_FETCH_R:
1294 case ZEND_FE_FETCH_RW:
1295 case ZEND_SWITCH_LONG:
1296 case ZEND_SWITCH_STRING:
1297 case ZEND_MATCH:
1298 /* relative extended_value don't have to be changed */
1299 break;
1300 #endif
1301 case ZEND_IS_IDENTICAL:
1302 case ZEND_IS_NOT_IDENTICAL:
1303 case ZEND_IS_EQUAL:
1304 case ZEND_IS_NOT_EQUAL:
1305 case ZEND_IS_SMALLER:
1306 case ZEND_IS_SMALLER_OR_EQUAL:
1307 case ZEND_CASE:
1308 case ZEND_CASE_STRICT:
1309 case ZEND_ISSET_ISEMPTY_CV:
1310 case ZEND_ISSET_ISEMPTY_VAR:
1311 case ZEND_ISSET_ISEMPTY_DIM_OBJ:
1312 case ZEND_ISSET_ISEMPTY_PROP_OBJ:
1313 case ZEND_ISSET_ISEMPTY_STATIC_PROP:
1314 case ZEND_INSTANCEOF:
1315 case ZEND_TYPE_CHECK:
1316 case ZEND_DEFINED:
1317 case ZEND_IN_ARRAY:
1318 case ZEND_ARRAY_KEY_EXISTS:
1319 if (opline->result_type & IS_TMP_VAR) {
1320 /* reinitialize result_type of smart branch instructions */
1321 if (opline + 1 < end) {
1322 if ((opline+1)->opcode == ZEND_JMPZ
1323 && (opline+1)->op1_type == IS_TMP_VAR
1324 && (opline+1)->op1.var == opline->result.var) {
1325 opline->result_type = IS_SMART_BRANCH_JMPZ | IS_TMP_VAR;
1326 } else if ((opline+1)->opcode == ZEND_JMPNZ
1327 && (opline+1)->op1_type == IS_TMP_VAR
1328 && (opline+1)->op1.var == opline->result.var) {
1329 opline->result_type = IS_SMART_BRANCH_JMPNZ | IS_TMP_VAR;
1330 }
1331 }
1332 }
1333 break;
1334 }
1335 zend_vm_set_opcode_handler_ex(opline, op1_info, op2_info, res_info);
1336 opline++;
1337 }
1338
1339 op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
1340 }
1341
zend_optimize_op_array(zend_op_array * op_array,zend_optimizer_ctx * ctx)1342 static void zend_optimize_op_array(zend_op_array *op_array,
1343 zend_optimizer_ctx *ctx)
1344 {
1345 /* Revert pass_two() */
1346 zend_revert_pass_two(op_array);
1347
1348 /* Do actual optimizations */
1349 zend_optimize(op_array, ctx);
1350
1351 /* Redo pass_two() */
1352 zend_redo_pass_two(op_array);
1353
1354 if (op_array->live_range) {
1355 zend_recalc_live_ranges(op_array, NULL);
1356 }
1357 }
1358
zend_adjust_fcall_stack_size(zend_op_array * op_array,zend_optimizer_ctx * ctx)1359 static void zend_adjust_fcall_stack_size(zend_op_array *op_array, zend_optimizer_ctx *ctx)
1360 {
1361 zend_function *func;
1362 zend_op *opline, *end;
1363
1364 opline = op_array->opcodes;
1365 end = opline + op_array->last;
1366 while (opline < end) {
1367 if (opline->opcode == ZEND_INIT_FCALL) {
1368 func = zend_hash_find_ptr(
1369 &ctx->script->function_table,
1370 Z_STR_P(RT_CONSTANT(opline, opline->op2)));
1371 if (func) {
1372 opline->op1.num = zend_vm_calc_used_stack(opline->extended_value, func);
1373 }
1374 }
1375 opline++;
1376 }
1377 }
1378
zend_adjust_fcall_stack_size_graph(zend_op_array * op_array)1379 static void zend_adjust_fcall_stack_size_graph(zend_op_array *op_array)
1380 {
1381 zend_func_info *func_info = ZEND_FUNC_INFO(op_array);
1382
1383 if (func_info) {
1384 zend_call_info *call_info =func_info->callee_info;
1385
1386 while (call_info) {
1387 zend_op *opline = call_info->caller_init_opline;
1388
1389 if (opline && call_info->callee_func && opline->opcode == ZEND_INIT_FCALL) {
1390 ZEND_ASSERT(!call_info->is_prototype);
1391 opline->op1.num = zend_vm_calc_used_stack(opline->extended_value, call_info->callee_func);
1392 }
1393 call_info = call_info->next_callee;
1394 }
1395 }
1396 }
1397
needs_live_range(zend_op_array * op_array,zend_op * def_opline)1398 static bool needs_live_range(zend_op_array *op_array, zend_op *def_opline) {
1399 zend_func_info *func_info = ZEND_FUNC_INFO(op_array);
1400 zend_ssa_op *ssa_op = &func_info->ssa.ops[def_opline - op_array->opcodes];
1401 int ssa_var = ssa_op->result_def;
1402 if (ssa_var < 0) {
1403 /* Be conservative. */
1404 return 1;
1405 }
1406
1407 /* If the variable is used by a PHI, this may be the assignment of the final branch of a
1408 * ternary/etc structure. While this is where the live range starts, the value from the other
1409 * branch may also be used. As such, use the type of the PHI node for the following check. */
1410 if (func_info->ssa.vars[ssa_var].phi_use_chain) {
1411 ssa_var = func_info->ssa.vars[ssa_var].phi_use_chain->ssa_var;
1412 }
1413
1414 uint32_t type = func_info->ssa.var_info[ssa_var].type;
1415 return (type & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF)) != 0;
1416 }
1417
zend_foreach_op_array_helper(zend_op_array * op_array,zend_op_array_func_t func,void * context)1418 static void zend_foreach_op_array_helper(
1419 zend_op_array *op_array, zend_op_array_func_t func, void *context) {
1420 func(op_array, context);
1421 for (uint32_t i = 0; i < op_array->num_dynamic_func_defs; i++) {
1422 zend_foreach_op_array_helper(op_array->dynamic_func_defs[i], func, context);
1423 }
1424 }
1425
zend_foreach_op_array(zend_script * script,zend_op_array_func_t func,void * context)1426 void zend_foreach_op_array(zend_script *script, zend_op_array_func_t func, void *context)
1427 {
1428 zval *zv;
1429 zend_op_array *op_array;
1430
1431 zend_foreach_op_array_helper(&script->main_op_array, func, context);
1432
1433 ZEND_HASH_MAP_FOREACH_PTR(&script->function_table, op_array) {
1434 zend_foreach_op_array_helper(op_array, func, context);
1435 } ZEND_HASH_FOREACH_END();
1436
1437 ZEND_HASH_MAP_FOREACH_VAL(&script->class_table, zv) {
1438 if (Z_TYPE_P(zv) == IS_ALIAS_PTR) {
1439 continue;
1440 }
1441 zend_class_entry *ce = Z_CE_P(zv);
1442 ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, op_array) {
1443 if (op_array->scope == ce
1444 && op_array->type == ZEND_USER_FUNCTION
1445 && !(op_array->fn_flags & ZEND_ACC_ABSTRACT)
1446 && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
1447 zend_foreach_op_array_helper(op_array, func, context);
1448 }
1449 } ZEND_HASH_FOREACH_END();
1450 } ZEND_HASH_FOREACH_END();
1451 }
1452
step_optimize_op_array(zend_op_array * op_array,void * context)1453 static void step_optimize_op_array(zend_op_array *op_array, void *context) {
1454 zend_optimize_op_array(op_array, (zend_optimizer_ctx *) context);
1455 }
1456
step_adjust_fcall_stack_size(zend_op_array * op_array,void * context)1457 static void step_adjust_fcall_stack_size(zend_op_array *op_array, void *context) {
1458 zend_adjust_fcall_stack_size(op_array, (zend_optimizer_ctx *) context);
1459 }
1460
step_dump_after_optimizer(zend_op_array * op_array,void * context)1461 static void step_dump_after_optimizer(zend_op_array *op_array, void *context) {
1462 zend_dump_op_array(op_array, ZEND_DUMP_LIVE_RANGES, "after optimizer", NULL);
1463 }
1464
zend_optimizer_call_registered_passes(zend_script * script,void * ctx)1465 static void zend_optimizer_call_registered_passes(zend_script *script, void *ctx) {
1466 for (int i = 0; i < zend_optimizer_registered_passes.last; i++) {
1467 if (!zend_optimizer_registered_passes.pass[i]) {
1468 continue;
1469 }
1470
1471 zend_optimizer_registered_passes.pass[i](script, ctx);
1472 }
1473 }
1474
zend_optimize_script(zend_script * script,zend_long optimization_level,zend_long debug_level)1475 ZEND_API void zend_optimize_script(zend_script *script, zend_long optimization_level, zend_long debug_level)
1476 {
1477 zend_op_array *op_array;
1478 zend_string *name;
1479 zend_optimizer_ctx ctx;
1480 zval *zv;
1481
1482 ctx.arena = zend_arena_create(64 * 1024);
1483 ctx.script = script;
1484 ctx.constants = NULL;
1485 ctx.optimization_level = optimization_level;
1486 ctx.debug_level = debug_level;
1487
1488 if ((ZEND_OPTIMIZER_PASS_6 & optimization_level) &&
1489 (ZEND_OPTIMIZER_PASS_7 & optimization_level)) {
1490 /* Optimize using call-graph */
1491 zend_call_graph call_graph;
1492 zend_build_call_graph(&ctx.arena, script, &call_graph);
1493
1494 int i;
1495 zend_func_info *func_info;
1496
1497 for (i = 0; i < call_graph.op_arrays_count; i++) {
1498 zend_revert_pass_two(call_graph.op_arrays[i]);
1499 zend_optimize(call_graph.op_arrays[i], &ctx);
1500 }
1501
1502 zend_analyze_call_graph(&ctx.arena, script, &call_graph);
1503
1504 for (i = 0; i < call_graph.op_arrays_count; i++) {
1505 func_info = ZEND_FUNC_INFO(call_graph.op_arrays[i]);
1506 if (func_info) {
1507 func_info->call_map = zend_build_call_map(&ctx.arena, func_info, call_graph.op_arrays[i]);
1508 if (call_graph.op_arrays[i]->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
1509 zend_init_func_return_info(call_graph.op_arrays[i], script, &func_info->return_info);
1510 }
1511 }
1512 }
1513
1514 for (i = 0; i < call_graph.op_arrays_count; i++) {
1515 func_info = ZEND_FUNC_INFO(call_graph.op_arrays[i]);
1516 if (func_info) {
1517 if (zend_dfa_analyze_op_array(call_graph.op_arrays[i], &ctx, &func_info->ssa) == SUCCESS) {
1518 func_info->flags = func_info->ssa.cfg.flags;
1519 } else {
1520 ZEND_SET_FUNC_INFO(call_graph.op_arrays[i], NULL);
1521 }
1522 }
1523 }
1524
1525 //TODO: perform inner-script inference???
1526 for (i = 0; i < call_graph.op_arrays_count; i++) {
1527 func_info = ZEND_FUNC_INFO(call_graph.op_arrays[i]);
1528 if (func_info) {
1529 zend_dfa_optimize_op_array(call_graph.op_arrays[i], &ctx, &func_info->ssa, func_info->call_map);
1530 }
1531 }
1532
1533 if (debug_level & ZEND_DUMP_AFTER_PASS_7) {
1534 for (i = 0; i < call_graph.op_arrays_count; i++) {
1535 zend_dump_op_array(call_graph.op_arrays[i], 0, "after pass 7", NULL);
1536 }
1537 }
1538
1539 if (ZEND_OPTIMIZER_PASS_9 & optimization_level) {
1540 for (i = 0; i < call_graph.op_arrays_count; i++) {
1541 zend_optimize_temporary_variables(call_graph.op_arrays[i], &ctx);
1542 if (debug_level & ZEND_DUMP_AFTER_PASS_9) {
1543 zend_dump_op_array(call_graph.op_arrays[i], 0, "after pass 9", NULL);
1544 }
1545 }
1546 }
1547
1548 if (ZEND_OPTIMIZER_PASS_11 & optimization_level) {
1549 for (i = 0; i < call_graph.op_arrays_count; i++) {
1550 zend_optimizer_compact_literals(call_graph.op_arrays[i], &ctx);
1551 if (debug_level & ZEND_DUMP_AFTER_PASS_11) {
1552 zend_dump_op_array(call_graph.op_arrays[i], 0, "after pass 11", NULL);
1553 }
1554 }
1555 }
1556
1557 if (ZEND_OPTIMIZER_PASS_13 & optimization_level) {
1558 for (i = 0; i < call_graph.op_arrays_count; i++) {
1559 zend_optimizer_compact_vars(call_graph.op_arrays[i]);
1560 if (debug_level & ZEND_DUMP_AFTER_PASS_13) {
1561 zend_dump_op_array(call_graph.op_arrays[i], 0, "after pass 13", NULL);
1562 }
1563 }
1564 }
1565
1566 if (ZEND_OBSERVER_ENABLED) {
1567 for (i = 0; i < call_graph.op_arrays_count; i++) {
1568 ++call_graph.op_arrays[i]->T; // ensure accurate temporary count for stack size precalculation
1569 }
1570 }
1571
1572 if (ZEND_OPTIMIZER_PASS_12 & optimization_level) {
1573 for (i = 0; i < call_graph.op_arrays_count; i++) {
1574 zend_adjust_fcall_stack_size_graph(call_graph.op_arrays[i]);
1575 }
1576 }
1577
1578 for (i = 0; i < call_graph.op_arrays_count; i++) {
1579 op_array = call_graph.op_arrays[i];
1580 func_info = ZEND_FUNC_INFO(op_array);
1581 if (func_info && func_info->ssa.var_info) {
1582 zend_redo_pass_two_ex(op_array, &func_info->ssa);
1583 if (op_array->live_range) {
1584 zend_recalc_live_ranges(op_array, needs_live_range);
1585 }
1586 } else {
1587 op_array->T -= ZEND_OBSERVER_ENABLED; // redo_pass_two will re-increment it
1588
1589 zend_redo_pass_two(op_array);
1590 if (op_array->live_range) {
1591 zend_recalc_live_ranges(op_array, NULL);
1592 }
1593 }
1594 }
1595
1596 for (i = 0; i < call_graph.op_arrays_count; i++) {
1597 ZEND_SET_FUNC_INFO(call_graph.op_arrays[i], NULL);
1598 }
1599 } else {
1600 zend_foreach_op_array(script, step_optimize_op_array, &ctx);
1601
1602 if (ZEND_OPTIMIZER_PASS_12 & optimization_level) {
1603 zend_foreach_op_array(script, step_adjust_fcall_stack_size, &ctx);
1604 }
1605 }
1606
1607 ZEND_HASH_MAP_FOREACH_VAL(&script->class_table, zv) {
1608 if (Z_TYPE_P(zv) == IS_ALIAS_PTR) {
1609 continue;
1610 }
1611 zend_class_entry *ce = Z_CE_P(zv);
1612 ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
1613 if (op_array->scope != ce && op_array->type == ZEND_USER_FUNCTION) {
1614 zend_op_array *orig_op_array =
1615 zend_hash_find_ptr(&op_array->scope->function_table, name);
1616
1617 ZEND_ASSERT(orig_op_array != NULL);
1618 if (orig_op_array != op_array) {
1619 uint32_t fn_flags = op_array->fn_flags;
1620 zend_function *prototype = op_array->prototype;
1621 HashTable *ht = op_array->static_variables;
1622
1623 *op_array = *orig_op_array;
1624 op_array->fn_flags = fn_flags;
1625 op_array->prototype = prototype;
1626 op_array->static_variables = ht;
1627 }
1628 }
1629 } ZEND_HASH_FOREACH_END();
1630 } ZEND_HASH_FOREACH_END();
1631
1632 zend_optimizer_call_registered_passes(script, &ctx);
1633
1634 if ((debug_level & ZEND_DUMP_AFTER_OPTIMIZER) &&
1635 (ZEND_OPTIMIZER_PASS_7 & optimization_level)) {
1636 zend_foreach_op_array(script, step_dump_after_optimizer, NULL);
1637 }
1638
1639 if (ctx.constants) {
1640 zend_hash_destroy(ctx.constants);
1641 }
1642 zend_arena_destroy(ctx.arena);
1643 }
1644
zend_optimizer_register_pass(zend_optimizer_pass_t pass)1645 ZEND_API int zend_optimizer_register_pass(zend_optimizer_pass_t pass)
1646 {
1647 if (!pass) {
1648 return -1;
1649 }
1650
1651 if (zend_optimizer_registered_passes.last == ZEND_OPTIMIZER_MAX_REGISTERED_PASSES) {
1652 return -1;
1653 }
1654
1655 zend_optimizer_registered_passes.pass[
1656 zend_optimizer_registered_passes.last++] = pass;
1657
1658 return zend_optimizer_registered_passes.last;
1659 }
1660
zend_optimizer_unregister_pass(int idx)1661 ZEND_API void zend_optimizer_unregister_pass(int idx)
1662 {
1663 zend_optimizer_registered_passes.pass[idx-1] = NULL;
1664 }
1665
zend_optimizer_startup(void)1666 zend_result zend_optimizer_startup(void)
1667 {
1668 return zend_func_info_startup();
1669 }
1670
zend_optimizer_shutdown(void)1671 zend_result zend_optimizer_shutdown(void)
1672 {
1673 return zend_func_info_shutdown();
1674 }
1675