source: src/router/php7/ext/opcache/Optimizer/dfa_pass.c @ 31874

Last change on this file since 31874 was 31874, checked in by brainslayer, 3 months ago

update php

File size: 21.5 KB
Line 
1/*
2   +----------------------------------------------------------------------+
3   | Zend OPcache                                                         |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1998-2017 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   | http://www.php.net/license/3_01.txt                                  |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Authors: Dmitry Stogov <dmitry@zend.com>                             |
16   +----------------------------------------------------------------------+
17*/
18
19#include "php.h"
20#include "Optimizer/zend_optimizer.h"
21#include "Optimizer/zend_optimizer_internal.h"
22#include "zend_API.h"
23#include "zend_constants.h"
24#include "zend_execute.h"
25#include "zend_vm.h"
26#include "zend_bitset.h"
27#include "zend_cfg.h"
28#include "zend_ssa.h"
29#include "zend_func_info.h"
30#include "zend_call_graph.h"
31#include "zend_inference.h"
32#include "zend_dump.h"
33
34int zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa, uint32_t *flags)
35{
36        uint32_t build_flags;
37
38        if (op_array->last_try_catch) {
39                /* TODO: we can't analyze functions with try/catch/finally ??? */
40                return FAILURE;
41        }
42
43    /* Build SSA */
44        memset(ssa, 0, sizeof(zend_ssa));
45
46        if (zend_build_cfg(&ctx->arena, op_array,
47                        ZEND_CFG_NO_ENTRY_PREDECESSORS, &ssa->cfg, flags) != SUCCESS) {
48                return FAILURE;
49        }
50
51        if (*flags & ZEND_FUNC_INDIRECT_VAR_ACCESS) {
52                /* TODO: we can't analyze functions with indirect variable access ??? */
53                return FAILURE;
54        }
55
56        if (zend_cfg_build_predecessors(&ctx->arena, &ssa->cfg) != SUCCESS) {
57                return FAILURE;
58        }
59
60        if (ctx->debug_level & ZEND_DUMP_DFA_CFG) {
61                zend_dump_op_array(op_array, ZEND_DUMP_CFG, "dfa cfg", &ssa->cfg);
62        }
63
64        /* Compute Dominators Tree */
65        if (zend_cfg_compute_dominators_tree(op_array, &ssa->cfg) != SUCCESS) {
66                return FAILURE;
67        }
68
69        /* Identify reducible and irreducible loops */
70        if (zend_cfg_identify_loops(op_array, &ssa->cfg, flags) != SUCCESS) {
71                return FAILURE;
72        }
73
74        if (ctx->debug_level & ZEND_DUMP_DFA_DOMINATORS) {
75                zend_dump_dominators(op_array, &ssa->cfg);
76        }
77
78        build_flags = 0;
79        if (ctx->debug_level & ZEND_DUMP_DFA_LIVENESS) {
80                build_flags |= ZEND_SSA_DEBUG_LIVENESS;
81        }
82        if (ctx->debug_level & ZEND_DUMP_DFA_PHI) {
83                build_flags |= ZEND_SSA_DEBUG_PHI_PLACEMENT;
84        }
85        if (zend_build_ssa(&ctx->arena, ctx->script, op_array, build_flags, ssa, flags) != SUCCESS) {
86                return FAILURE;
87        }
88
89        if (ctx->debug_level & ZEND_DUMP_DFA_SSA) {
90                zend_dump_op_array(op_array, ZEND_DUMP_SSA, "before dfa pass", ssa);
91        }
92
93
94        if (zend_ssa_compute_use_def_chains(&ctx->arena, op_array, ssa) != SUCCESS){
95                return FAILURE;
96        }
97
98        if (zend_ssa_find_false_dependencies(op_array, ssa) != SUCCESS) {
99                return FAILURE;
100        }
101
102        if (zend_ssa_find_sccs(op_array, ssa) != SUCCESS){
103                return FAILURE;
104        }
105
106        if (zend_ssa_inference(&ctx->arena, op_array, ctx->script, ssa) != SUCCESS) {
107                return FAILURE;
108        }
109
110        if (ctx->debug_level & ZEND_DUMP_DFA_SSA_VARS) {
111                zend_dump_ssa_variables(op_array, ssa, 0);
112        }
113
114        return SUCCESS;
115}
116
117static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa)
118{
119        zend_basic_block *blocks = ssa->cfg.blocks;
120        zend_basic_block *end = blocks + ssa->cfg.blocks_count;
121        zend_basic_block *b;
122        zend_func_info *func_info;
123        int j;
124        uint32_t i;
125        uint32_t target = 0;
126        uint32_t *shiftlist;
127        ALLOCA_FLAG(use_heap);
128
129        shiftlist = (uint32_t *)do_alloca(sizeof(uint32_t) * op_array->last, use_heap);
130        memset(shiftlist, 0, sizeof(uint32_t) * op_array->last);
131        for (b = blocks; b < end; b++) {
132                if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
133                        uint32_t end;
134                        if (b->flags & ZEND_BB_UNREACHABLE_FREE) {
135                                /* Only keep the FREE for the loop var */
136                                ZEND_ASSERT(op_array->opcodes[b->start].opcode == ZEND_FREE
137                                                || op_array->opcodes[b->start].opcode == ZEND_FE_FREE);
138                                b->len = 1;
139                        }
140
141                        end = b->start + b->len;
142                        i = b->start;
143                        b->start = target;
144                        while (i < end) {
145                                shiftlist[i] = i - target;
146                                if (EXPECTED(op_array->opcodes[i].opcode != ZEND_NOP) ||
147                                   /*keep NOP to support ZEND_VM_SMART_BRANCH */
148                                   (i > 0 &&
149                                    i + 1 < op_array->last &&
150                                    (op_array->opcodes[i+1].opcode == ZEND_JMPZ ||
151                                     op_array->opcodes[i+1].opcode == ZEND_JMPNZ) &&
152                                    zend_is_smart_branch(op_array->opcodes + i - 1))) {
153                                        if (i != target) {
154                                                op_array->opcodes[target] = op_array->opcodes[i];
155                                                ssa->ops[target] = ssa->ops[i];
156                                        }
157                                        target++;
158                                }
159                                i++;
160                        }
161                        if (target != end && b->len != 0) {
162                                zend_op *opline;
163                                zend_op *new_opline;
164
165                                opline = op_array->opcodes + end - 1;
166                                b->len = target - b->start;
167                                new_opline = op_array->opcodes + target - 1;
168                                switch (new_opline->opcode) {
169                                        case ZEND_JMP:
170                                        case ZEND_FAST_CALL:
171                                                ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op1, ZEND_OP1_JMP_ADDR(opline));
172                                                break;
173                                        case ZEND_JMPZNZ:
174                                                new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
175                                                /* break missing intentionally */
176                                        case ZEND_JMPZ:
177                                        case ZEND_JMPNZ:
178                                        case ZEND_JMPZ_EX:
179                                        case ZEND_JMPNZ_EX:
180                                        case ZEND_FE_RESET_R:
181                                        case ZEND_FE_RESET_RW:
182                                        case ZEND_JMP_SET:
183                                        case ZEND_COALESCE:
184                                        case ZEND_ASSERT_CHECK:
185                                                ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op2, ZEND_OP2_JMP_ADDR(opline));
186                                                break;
187                                        case ZEND_CATCH:
188                                                if (!opline->result.num) {
189                                                        new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
190                                                }
191                                                break;
192                                        case ZEND_DECLARE_ANON_CLASS:
193                                        case ZEND_DECLARE_ANON_INHERITED_CLASS:
194                                        case ZEND_FE_FETCH_R:
195                                        case ZEND_FE_FETCH_RW:
196                                                new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
197                                                break;
198                                }
199                        }
200                }
201        }
202
203        if (target != op_array->last) {
204                /* reset rest opcodes */
205                for (i = target; i < op_array->last; i++) {
206                        MAKE_NOP(op_array->opcodes + i);
207                }
208
209                /* update SSA variables */
210                for (j = 0; j < ssa->vars_count; j++) {
211                        if (ssa->vars[j].definition >= 0) {
212                                ssa->vars[j].definition -= shiftlist[ssa->vars[j].definition];
213                        }
214                        if (ssa->vars[j].use_chain >= 0) {
215                                ssa->vars[j].use_chain -= shiftlist[ssa->vars[j].use_chain];
216                        }
217                }
218                for (i = 0; i < op_array->last; i++) {
219                        if (ssa->ops[i].op1_use_chain >= 0) {
220                                ssa->ops[i].op1_use_chain -= shiftlist[ssa->ops[i].op1_use_chain];
221                        }
222                        if (ssa->ops[i].op2_use_chain >= 0) {
223                                ssa->ops[i].op2_use_chain -= shiftlist[ssa->ops[i].op2_use_chain];
224                        }
225                        if (ssa->ops[i].res_use_chain >= 0) {
226                                ssa->ops[i].res_use_chain -= shiftlist[ssa->ops[i].res_use_chain];
227                        }
228                }
229
230                /* update branch targets */
231                for (b = blocks; b < end; b++) {
232                        if ((b->flags & ZEND_BB_REACHABLE) && b->len != 0) {
233                                zend_op *opline = op_array->opcodes + b->start + b->len - 1;
234
235                                switch (opline->opcode) {
236                                        case ZEND_JMP:
237                                        case ZEND_FAST_CALL:
238                                                ZEND_SET_OP_JMP_ADDR(opline, opline->op1, ZEND_OP1_JMP_ADDR(opline) - shiftlist[ZEND_OP1_JMP_ADDR(opline) - op_array->opcodes]);
239                                                break;
240                                        case ZEND_JMPZNZ:
241                                                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)]);
242                                                /* break missing intentionally */
243                                        case ZEND_JMPZ:
244                                        case ZEND_JMPNZ:
245                                        case ZEND_JMPZ_EX:
246                                        case ZEND_JMPNZ_EX:
247                                        case ZEND_FE_RESET_R:
248                                        case ZEND_FE_RESET_RW:
249                                        case ZEND_JMP_SET:
250                                        case ZEND_COALESCE:
251                                        case ZEND_ASSERT_CHECK:
252                                                ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP2_JMP_ADDR(opline) - shiftlist[ZEND_OP2_JMP_ADDR(opline) - op_array->opcodes]);
253                                                break;
254                                        case ZEND_DECLARE_ANON_CLASS:
255                                        case ZEND_DECLARE_ANON_INHERITED_CLASS:
256                                        case ZEND_FE_FETCH_R:
257                                        case ZEND_FE_FETCH_RW:
258                                        case ZEND_CATCH:
259                                                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)]);
260                                                break;
261                                }
262                        }
263                }
264
265                /* update brk/cont array */
266                for (j = 0; j < op_array->last_live_range; j++) {
267                        op_array->live_range[j].start -= shiftlist[op_array->live_range[j].start];
268                        op_array->live_range[j].end   -= shiftlist[op_array->live_range[j].end];
269                }
270
271                /* update try/catch array */
272                for (j = 0; j < op_array->last_try_catch; j++) {
273                        op_array->try_catch_array[j].try_op -= shiftlist[op_array->try_catch_array[j].try_op];
274                        op_array->try_catch_array[j].catch_op -= shiftlist[op_array->try_catch_array[j].catch_op];
275                        if (op_array->try_catch_array[j].finally_op) {
276                                op_array->try_catch_array[j].finally_op -= shiftlist[op_array->try_catch_array[j].finally_op];
277                                op_array->try_catch_array[j].finally_end -= shiftlist[op_array->try_catch_array[j].finally_end];
278                        }
279                }
280
281                /* update early binding list */
282                if (op_array->early_binding != (uint32_t)-1) {
283                        uint32_t *opline_num = &op_array->early_binding;
284
285                        do {
286                                *opline_num -= shiftlist[*opline_num];
287                                opline_num = &ZEND_RESULT(&op_array->opcodes[*opline_num]).opline_num;
288                        } while (*opline_num != (uint32_t)-1);
289                }
290
291                /* update call graph */
292                func_info = ZEND_FUNC_INFO(op_array);
293                if (func_info) {
294                        zend_call_info *call_info = func_info->callee_info;
295                        while (call_info) {
296                                call_info->caller_init_opline -=
297                                        shiftlist[call_info->caller_init_opline - op_array->opcodes];
298                                call_info->caller_call_opline -=
299                                        shiftlist[call_info->caller_call_opline - op_array->opcodes];
300                                call_info = call_info->next_callee;
301                        }
302                }
303
304                op_array->last = target;
305        }
306        free_alloca(shiftlist, use_heap);
307}
308
309static inline zend_bool can_elide_return_type_check(
310                zend_op_array *op_array, zend_ssa *ssa, zend_ssa_op *ssa_op) {
311        zend_arg_info *info = &op_array->arg_info[-1];
312        zend_ssa_var_info *use_info = &ssa->var_info[ssa_op->op1_use];
313        zend_ssa_var_info *def_info = &ssa->var_info[ssa_op->op1_def];
314
315        if (use_info->type & MAY_BE_REF) {
316                return 0;
317        }
318
319        /* A type is possible that is not in the allowed types */
320        if ((use_info->type & (MAY_BE_ANY|MAY_BE_UNDEF)) & ~(def_info->type & MAY_BE_ANY)) {
321                return 0;
322        }
323
324        if (info->type_hint == IS_CALLABLE) {
325                return 0;
326        }
327
328        if (info->class_name) {
329                if (!use_info->ce || !def_info->ce || !instanceof_function(use_info->ce, def_info->ce)) {
330                        return 0;
331                }
332        }
333
334        return 1;
335}
336
337static zend_bool opline_supports_assign_contraction(
338                zend_ssa *ssa, zend_op *opline, int src_var, uint32_t cv_var) {
339        if (opline->opcode == ZEND_NEW) {
340                /* see Zend/tests/generators/aborted_yield_during_new.phpt */
341                return 0;
342        }
343
344        if (opline->opcode == ZEND_DO_ICALL || opline->opcode == ZEND_DO_UCALL
345                        || opline->opcode == ZEND_DO_FCALL || opline->opcode == ZEND_DO_FCALL_BY_NAME) {
346                /* Function calls may dtor the return value after it has already been written -- allow
347                 * direct assignment only for types where a double-dtor does not matter. */
348                uint32_t type = ssa->var_info[src_var].type;
349                uint32_t simple = MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE;
350                return !((type & MAY_BE_ANY) & ~simple);
351        }
352
353        if (opline->opcode == ZEND_POST_INC || opline->opcode == ZEND_POST_DEC) {
354                /* POST_INC/DEC write the result variable before performing the inc/dec. For $i = $i++
355                 * eliding the temporary variable would thus yield an incorrect result. */
356                return opline->op1_type != IS_CV || opline->op1.var != cv_var;
357        }
358
359        if (opline->opcode == ZEND_INIT_ARRAY) {
360                /* INIT_ARRAY initializes the result array before reading key/value. */
361                return (opline->op1_type != IS_CV || opline->op1.var != cv_var)
362                        && (opline->op2_type != IS_CV || opline->op2.var != cv_var);
363        }
364
365        return 1;
366}
367
368void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa)
369{
370        if (ctx->debug_level & ZEND_DUMP_BEFORE_DFA_PASS) {
371                zend_dump_op_array(op_array, ZEND_DUMP_SSA, "before dfa pass", ssa);
372        }
373
374        if (ssa->var_info) {
375                int op_1;
376                int v;
377                int remove_nops = 0;
378                zend_op *opline;
379                zval tmp;
380
381                for (v = op_array->last_var; v < ssa->vars_count; v++) {
382
383                        op_1 = ssa->vars[v].definition;
384
385                        if (op_1 < 0) {
386                                continue;
387                        }
388
389                        opline = op_array->opcodes + op_1;
390
391                        /* Convert LONG constants to DOUBLE */
392                        if (ssa->var_info[v].use_as_double) {
393                                if (opline->opcode == ZEND_ASSIGN
394                                 && opline->op2_type == IS_CONST
395                                 && ssa->ops[op_1].op1_def == v
396                                 && !RETURN_VALUE_USED(opline)
397                                ) {
398
399// op_1: ASSIGN ? -> #v [use_as_double], long(?) => ASSIGN ? -> #v, double(?)
400
401                                        zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant);
402                                        ZEND_ASSERT(Z_TYPE_INFO_P(zv) == IS_LONG);
403                                        ZVAL_DOUBLE(&tmp, zval_get_double(zv));
404                                        opline->op2.constant = zend_optimizer_add_literal(op_array, &tmp);
405
406                                } else if (opline->opcode == ZEND_QM_ASSIGN
407                                 && opline->op1_type == IS_CONST
408                                ) {
409
410// op_1: QM_ASSIGN #v [use_as_double], long(?) => QM_ASSIGN #v, double(?)
411
412                                        zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant);
413                                        ZEND_ASSERT(Z_TYPE_INFO_P(zv) == IS_LONG);
414                                        ZVAL_DOUBLE(&tmp, zval_get_double(zv));
415                                        opline->op1.constant = zend_optimizer_add_literal(op_array, &tmp);
416                                }
417
418                        } else {
419                                if (opline->opcode == ZEND_ADD
420                                 || opline->opcode == ZEND_SUB
421                                 || opline->opcode == ZEND_MUL
422                                 || opline->opcode == ZEND_IS_EQUAL
423                                 || opline->opcode == ZEND_IS_NOT_EQUAL
424                                 || opline->opcode == ZEND_IS_SMALLER
425                                 || opline->opcode == ZEND_IS_SMALLER_OR_EQUAL
426                                ) {
427
428                                        if (opline->op1_type == IS_CONST
429                                         && opline->op2_type != IS_CONST
430                                         && (OP2_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE
431                                         && Z_TYPE_INFO_P(CT_CONSTANT_EX(op_array, opline->op1.constant)) == IS_LONG
432                                        ) {
433
434// op_1: #v.? = ADD long(?), #?.? [double] => #v.? = ADD double(?), #?.? [double]
435
436                                                zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant);
437                                                ZVAL_DOUBLE(&tmp, zval_get_double(zv));
438                                                opline->op1.constant = zend_optimizer_add_literal(op_array, &tmp);
439
440                                        } else if (opline->op1_type != IS_CONST
441                                         && opline->op2_type == IS_CONST
442                                         && (OP1_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE
443                                         && Z_TYPE_INFO_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == IS_LONG
444                                        ) {
445
446// op_1: #v.? = ADD #?.? [double], long(?) => #v.? = ADD #?.? [double], double(?)
447
448                                                zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant);
449                                                ZVAL_DOUBLE(&tmp, zval_get_double(zv));
450                                                opline->op2.constant = zend_optimizer_add_literal(op_array, &tmp);
451                                        }
452                                }
453                        }
454
455                        if (ssa->vars[v].var >= op_array->last_var) {
456                                /* skip TMP and VAR */
457                                continue;
458                        }
459
460                        if (opline->opcode == ZEND_ASSIGN
461                         && ssa->ops[op_1].op1_def == v
462                         && !RETURN_VALUE_USED(opline)
463                        ) {
464                                int orig_var = ssa->ops[op_1].op1_use;
465
466                                if (orig_var >= 0
467                                 && !(ssa->var_info[orig_var].type & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))
468                                ) {
469
470                                        int src_var = ssa->ops[op_1].op2_use;
471
472                                        if ((opline->op2_type & (IS_TMP_VAR|IS_VAR))
473                                         && src_var >= 0
474                                         && !(ssa->var_info[src_var].type & MAY_BE_REF)
475                                         && ssa->vars[src_var].definition >= 0
476                                         && ssa->ops[ssa->vars[src_var].definition].result_def == src_var
477                                         && ssa->ops[ssa->vars[src_var].definition].result_use < 0
478                                         && ssa->vars[src_var].use_chain == op_1
479                                         && ssa->ops[op_1].op2_use_chain < 0
480                                         && !ssa->vars[src_var].phi_use_chain
481                                         && !ssa->vars[src_var].sym_use_chain
482                                         && opline_supports_assign_contraction(
483                                                 ssa, &op_array->opcodes[ssa->vars[src_var].definition],
484                                                 src_var, opline->op1.var)
485                                        ) {
486
487                                                int op_2 = ssa->vars[src_var].definition;
488
489// op_2: #src_var.T = OP ...                                     => #v.CV = OP ...
490// op_1: ASSIGN #orig_var.CV [undef,scalar] -> #v.CV, #src_var.T    NOP
491
492                                                if (zend_ssa_unlink_use_chain(ssa, op_1, orig_var)) {
493                                                        /* Reconstruct SSA */
494                                                        ssa->vars[v].definition = op_2;
495                                                        ssa->ops[op_2].result_def = v;
496
497                                                        ssa->vars[src_var].definition = -1;
498                                                        ssa->vars[src_var].use_chain = -1;
499
500                                                        ssa->ops[op_1].op1_use = -1;
501                                                        ssa->ops[op_1].op2_use = -1;
502                                                        ssa->ops[op_1].op1_def = -1;
503                                                        ssa->ops[op_1].op1_use_chain = -1;
504
505                                                        /* Update opcodes */
506                                                        op_array->opcodes[op_2].result_type = opline->op1_type;
507                                                        op_array->opcodes[op_2].result.var = opline->op1.var;
508                                                        MAKE_NOP(opline);
509                                                        remove_nops = 1;
510                                                }
511                                        } else if (opline->op2_type == IS_CONST
512                                         || ((opline->op2_type & (IS_TMP_VAR|IS_VAR|IS_CV))
513                                             && ssa->ops[op_1].op2_use >= 0
514                                             && ssa->ops[op_1].op2_def < 0)
515                                        ) {
516
517// op_1: ASSIGN #orig_var.CV [undef,scalar] -> #v.CV, CONST|TMPVAR => QM_ASSIGN v.CV, CONST|TMPVAR
518
519                                                if (zend_ssa_unlink_use_chain(ssa, op_1, orig_var)) {
520                                                        /* Reconstruct SSA */
521                                                        ssa->ops[op_1].result_def = v;
522                                                        ssa->ops[op_1].op1_def = -1;
523                                                        ssa->ops[op_1].op1_use = ssa->ops[op_1].op2_use;
524                                                        ssa->ops[op_1].op1_use_chain = ssa->ops[op_1].op2_use_chain;
525                                                        ssa->ops[op_1].op2_use = -1;
526                                                        ssa->ops[op_1].op2_use_chain = -1;
527
528                                                        /* Update opcode */
529                                                        opline->result_type = opline->op1_type;
530                                                        opline->result.var = opline->op1.var;
531                                                        opline->op1_type = opline->op2_type;
532                                                        opline->op1.var = opline->op2.var;
533                                                        opline->op2_type = IS_UNUSED;
534                                                        opline->op2.var = 0;
535                                                        opline->opcode = ZEND_QM_ASSIGN;
536                                                }
537                                        }
538                                }
539
540                        } else if (opline->opcode == ZEND_ASSIGN_ADD
541                         && opline->extended_value == 0
542                         && ssa->ops[op_1].op1_def == v
543                         && opline->op2_type == IS_CONST
544                         && Z_TYPE_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == IS_LONG
545                         && Z_LVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == 1
546                         && ssa->ops[op_1].op1_use >= 0
547                         && !(ssa->var_info[ssa->ops[op_1].op1_use].type & (MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
548
549// op_1: ASSIGN_ADD #?.CV [undef,null,int,foat] ->#v.CV, int(1) => PRE_INC #?.CV ->#v.CV
550
551                                opline->opcode = ZEND_PRE_INC;
552                                SET_UNUSED(opline->op2);
553
554                        } else if (opline->opcode == ZEND_ASSIGN_SUB
555                         && opline->extended_value == 0
556                         && ssa->ops[op_1].op1_def == v
557                         && opline->op2_type == IS_CONST
558                         && Z_TYPE_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == IS_LONG
559                         && Z_LVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == 1
560                         && ssa->ops[op_1].op1_use >= 0
561                         && !(ssa->var_info[ssa->ops[op_1].op1_use].type & (MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
562
563// op_1: ASSIGN_SUB #?.CV [undef,null,int,foat] -> #v.CV, int(1) => PRE_DEC #?.CV ->#v.CV
564
565                                opline->opcode = ZEND_PRE_DEC;
566                                SET_UNUSED(opline->op2);
567
568                        } else if (opline->opcode == ZEND_VERIFY_RETURN_TYPE
569                         && ssa->ops[op_1].op1_def == v
570                         && ssa->ops[op_1].op1_use >= 0
571                         && ssa->ops[op_1].op1_use_chain == -1
572                         && ssa->vars[v].use_chain >= 0
573                         && can_elide_return_type_check(op_array, ssa, &ssa->ops[op_1])) {
574
575// op_1: VERIFY_RETURN_TYPE #orig_var.CV [T] -> #v.CV [T] => NOP
576
577                                int orig_var = ssa->ops[op_1].op1_use;
578                                if (zend_ssa_unlink_use_chain(ssa, op_1, orig_var)) {
579
580                                        int ret = ssa->vars[v].use_chain;
581
582                                        ssa->ops[ret].op1_use = orig_var;
583                                        ssa->ops[ret].op1_use_chain = ssa->vars[orig_var].use_chain;
584                                        ssa->vars[orig_var].use_chain = ret;
585
586                                        ssa->vars[v].definition = -1;
587                                        ssa->vars[v].use_chain = -1;
588
589                                        ssa->ops[op_1].op1_def = -1;
590                                        ssa->ops[op_1].op1_use = -1;
591
592                                        MAKE_NOP(opline);
593                                        remove_nops = 1;
594                                }
595
596                        } else if (ssa->ops[op_1].op1_def == v
597                         && !RETURN_VALUE_USED(opline)
598                         && ssa->ops[op_1].op1_use >= 0
599                         && !(ssa->var_info[ssa->ops[op_1].op1_use].type & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))
600                         && (opline->opcode == ZEND_ASSIGN_ADD
601                          || opline->opcode == ZEND_ASSIGN_SUB
602                          || opline->opcode == ZEND_ASSIGN_MUL
603                          || opline->opcode == ZEND_ASSIGN_DIV
604                          || opline->opcode == ZEND_ASSIGN_MOD
605                          || opline->opcode == ZEND_ASSIGN_SL
606                          || opline->opcode == ZEND_ASSIGN_SR
607                          || opline->opcode == ZEND_ASSIGN_BW_OR
608                          || opline->opcode == ZEND_ASSIGN_BW_AND
609                          || opline->opcode == ZEND_ASSIGN_BW_XOR)
610                         && opline->extended_value == 0) {
611
612// op_1: ASSIGN_ADD #orig_var.CV [undef,null,bool,int,double] -> #v.CV, ? => #v.CV = ADD #orig_var.CV, ?
613
614                                /* Reconstruct SSA */
615                                ssa->ops[op_1].result_def = ssa->ops[op_1].op1_def;
616                                ssa->ops[op_1].op1_def = -1;
617
618                                /* Update opcode */
619                                opline->opcode -= (ZEND_ASSIGN_ADD - ZEND_ADD);
620                                opline->result_type = opline->op1_type;
621                                opline->result.var = opline->op1.var;
622
623                        }
624                }
625
626                if (remove_nops) {
627                        zend_ssa_remove_nops(op_array, ssa);
628                }
629        }
630
631        if (ctx->debug_level & ZEND_DUMP_AFTER_DFA_PASS) {
632                zend_dump_op_array(op_array, ZEND_DUMP_SSA, "after dfa pass", ssa);
633        }
634}
635
636void zend_optimize_dfa(zend_op_array *op_array, zend_optimizer_ctx *ctx)
637{
638        void *checkpoint = zend_arena_checkpoint(ctx->arena);
639        uint32_t flags = 0;
640        zend_ssa ssa;
641
642        if (zend_dfa_analyze_op_array(op_array, ctx, &ssa, &flags) != SUCCESS) {
643                zend_arena_release(&ctx->arena, checkpoint);
644                return;
645        }
646
647        zend_dfa_optimize_op_array(op_array, ctx, &ssa);
648
649        /* Destroy SSA */
650        zend_arena_release(&ctx->arena, checkpoint);
651}
652
653/*
654 * Local variables:
655 * tab-width: 4
656 * c-basic-offset: 4
657 * indent-tabs-mode: t
658 * End:
659 */
Note: See TracBrowser for help on using the repository browser.