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

Source
/*
   +----------------------------------------------------------------------+
   | Zend Engine, Removing unused variables                               |
   +----------------------------------------------------------------------+
   | Copyright © The PHP Group and Contributors.                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | Authors: Nikita Popov <nikic@php.net>                                |
   +----------------------------------------------------------------------+
*/

#include "Optimizer/zend_optimizer_internal.h"
#include "zend_bitset.h"
#include "zend_observer.h"

/* This pass removes all CVs and temporaries that are completely unused. It does *not* merge any CVs or TMPs.
 * This pass does not operate on SSA form anymore. */
void zend_optimizer_compact_vars(zend_op_array *op_array) {
  int i;

  ALLOCA_FLAG(use_heap1);
  ALLOCA_FLAG(use_heap2);
  uint32_t used_vars_len = zend_bitset_len(op_array->last_var + op_array->T);
  zend_bitset used_vars = ZEND_BITSET_ALLOCA(used_vars_len, use_heap1);
  uint32_t *vars_map = do_alloca((op_array->last_var + op_array->T) * sizeof(uint32_t), use_heap2);
  uint32_t num_cvs, num_tmps;

  /* Determine which CVs are used */
  zend_bitset_clear(used_vars, used_vars_len);
  for (i = 0; i < op_array->last; i++) {
    const zend_op *opline = &op_array->opcodes[i];
    if (opline->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      zend_bitset_incl(used_vars, VAR_NUM(opline->op1.var));
    }
    if (opline->op2_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      zend_bitset_incl(used_vars, VAR_NUM(opline->op2.var));
    }
    if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      zend_bitset_incl(used_vars, VAR_NUM(opline->result.var));
      if (opline->opcode == ZEND_ROPE_INIT) {
        uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval);
        while (num > 1) {
          num--;
          zend_bitset_incl(used_vars, VAR_NUM(opline->result.var) + num);
        }
      }
    }
  }

  num_cvs = 0;
  for (i = 0; i < op_array->last_var; i++) {
    if (zend_bitset_in(used_vars, i)) {
      vars_map[i] = num_cvs++;
    } else {
      vars_map[i] = (uint32_t) -1;
    }
  }

  num_tmps = 0;
  for (i = op_array->last_var; i < op_array->last_var + op_array->T; i++) {
    if (zend_bitset_in(used_vars, i)) {
      vars_map[i] = num_cvs + num_tmps++;
    } else {
      vars_map[i] = (uint32_t) -1;
    }
  }

  free_alloca(used_vars, use_heap1);
  if (num_cvs == op_array->last_var && num_tmps == op_array->T) {
    free_alloca(vars_map, use_heap2);
    return;
  }

  ZEND_ASSERT(num_cvs <= op_array->last_var);
  ZEND_ASSERT(num_tmps <= op_array->T);

  /* Update CV and TMP references in opcodes */
  for (i = 0; i < op_array->last; i++) {
    zend_op *opline = &op_array->opcodes[i];
    if (opline->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      opline->op1.var = NUM_VAR(vars_map[VAR_NUM(opline->op1.var)]);
    }
    if (opline->op2_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      opline->op2.var = NUM_VAR(vars_map[VAR_NUM(opline->op2.var)]);
    }
    if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
      opline->result.var = NUM_VAR(vars_map[VAR_NUM(opline->result.var)]);
    }
  }

  /* Update CV name table */
  if (num_cvs != op_array->last_var) {
    if (num_cvs) {
      zend_string **names = safe_emalloc(sizeof(zend_string *), num_cvs, 0);
      for (i = 0; i < op_array->last_var; i++) {
        if (vars_map[i] != (uint32_t) -1) {
          names[vars_map[i]] = op_array->vars[i];
        } else {
          zend_string_release_ex(op_array->vars[i], 0);
        }
      }
      efree(op_array->vars);
      op_array->vars = names;
    } else {
      for (i = 0; i < op_array->last_var; i++) {
        zend_string_release_ex(op_array->vars[i], 0);
      }
      efree(op_array->vars);
      op_array->vars = NULL;
    }
    op_array->last_var = num_cvs;
  }

  op_array->T = num_tmps + ZEND_OBSERVER_ENABLED; // reserve last temporary for observers if enabled

  free_alloca(vars_map, use_heap2);
}

Line	Count	Source
1		/*
2		+----------------------------------------------------------------------+
3		\| Zend Engine, Removing unused variables \|
4		+----------------------------------------------------------------------+
5		\| Copyright © The PHP Group and Contributors. \|
6		+----------------------------------------------------------------------+
7		\| This source file is subject to the Modified BSD License that is \|
8		\| bundled with this package in the file LICENSE, and is available \|
9		\| through the World Wide Web at <https://www.php.net/license/>. \|
10		\| \|
11		\| SPDX-License-Identifier: BSD-3-Clause \|
12		+----------------------------------------------------------------------+
13		\| Authors: Nikita Popov <nikic@php.net> \|
14		+----------------------------------------------------------------------+
15		*/
16
17		#include "Optimizer/zend_optimizer_internal.h"
18		#include "zend_bitset.h"
19		#include "zend_observer.h"
20
21		/* This pass removes all CVs and temporaries that are completely unused. It does not merge any CVs or TMPs.
22		* This pass does not operate on SSA form anymore. */
23	115k	void zend_optimizer_compact_vars(zend_op_array *op_array) {
24	115k	int i;
25
26	115k	ALLOCA_FLAG(use_heap1);
27	115k	ALLOCA_FLAG(use_heap2);
28	115k	uint32_t used_vars_len = zend_bitset_len(op_array->last_var + op_array->T);
29	115k	zend_bitset used_vars = ZEND_BITSET_ALLOCA(used_vars_len, use_heap1);
30	115k	uint32_t vars_map = do_alloca((op_array->last_var + op_array->T) sizeof(uint32_t), use_heap2);
31	115k	uint32_t num_cvs, num_tmps;
32
33		/* Determine which CVs are used */
34	115k	zend_bitset_clear(used_vars, used_vars_len);
35	2.80M	for (i = 0; i < op_array->last; i++) {
36	2.69M	const zend_op *opline = &op_array->opcodes[i];
37	2.69M	if (opline->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
38	1.50M	zend_bitset_incl(used_vars, VAR_NUM(opline->op1.var));
39	1.50M	}
40	2.69M	if (opline->op2_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
41	534k	zend_bitset_incl(used_vars, VAR_NUM(opline->op2.var));
42	534k	}
43	2.69M	if (opline->result_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
44	1.30M	zend_bitset_incl(used_vars, VAR_NUM(opline->result.var));
45	1.30M	if (opline->opcode == ZEND_ROPE_INIT) {
46	32.4k	uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval);
47	196k	while (num > 1) {
48	164k	num--;
49	164k	zend_bitset_incl(used_vars, VAR_NUM(opline->result.var) + num);
50	164k	}
51	32.4k	}
52	1.30M	}
53	2.69M	}
54
55	115k	num_cvs = 0;
56	510k	for (i = 0; i < op_array->last_var; i++) {
57	394k	if (zend_bitset_in(used_vars, i)) {
58	387k	vars_map[i] = num_cvs++;
59	387k	} else {
60	7.36k	vars_map[i] = (uint32_t) -1;
61	7.36k	}
62	394k	}
63
64	115k	num_tmps = 0;
65	467k	for (i = op_array->last_var; i < op_array->last_var + op_array->T; i++) {
66	351k	if (zend_bitset_in(used_vars, i)) {
67	351k	vars_map[i] = num_cvs + num_tmps++;
68	351k	} else {
69	0	vars_map[i] = (uint32_t) -1;
70	0	}
71	351k	}
72
73	115k	free_alloca(used_vars, use_heap1);
74	115k	if (num_cvs == op_array->last_var && num_tmps == op_array->T) {
75	111k	free_alloca(vars_map, use_heap2);
76	111k	return;
77	111k	}
78
79	4.34k	ZEND_ASSERT(num_cvs <= op_array->last_var);
80	4.34k	ZEND_ASSERT(num_tmps <= op_array->T);
81
82		/* Update CV and TMP references in opcodes */
83	177k	for (i = 0; i < op_array->last; i++) {
84	173k	zend_op *opline = &op_array->opcodes[i];
85	173k	if (opline->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
86	113k	opline->op1.var = NUM_VAR(vars_map[VAR_NUM(opline->op1.var)]);
87	113k	}
88	173k	if (opline->op2_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
89	44.5k	opline->op2.var = NUM_VAR(vars_map[VAR_NUM(opline->op2.var)]);
90	44.5k	}
91	173k	if (opline->result_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
92	99.3k	opline->result.var = NUM_VAR(vars_map[VAR_NUM(opline->result.var)]);
93	99.3k	}
94	173k	}
95
96		/* Update CV name table */
97	4.34k	if (num_cvs != op_array->last_var) {
98	4.34k	if (num_cvs) {
99	3.95k	zend_string *names = safe_emalloc(sizeof(zend_string ), num_cvs, 0);
100	34.2k	for (i = 0; i < op_array->last_var; i++) {
101	30.2k	if (vars_map[i] != (uint32_t) -1) {
102	23.5k	names[vars_map[i]] = op_array->vars[i];
103	23.5k	} else {
104	6.75k	zend_string_release_ex(op_array->vars[i], 0);
105	6.75k	}
106	30.2k	}
107	3.95k	efree(op_array->vars);
108	3.95k	op_array->vars = names;
109	3.95k	} else {
110	992	for (i = 0; i < op_array->last_var; i++) {
111	602	zend_string_release_ex(op_array->vars[i], 0);
112	602	}
113	390	efree(op_array->vars);
114	390	op_array->vars = NULL;
115	390	}
116	4.34k	op_array->last_var = num_cvs;
117	4.34k	}
118
119	4.34k	op_array->T = num_tmps + ZEND_OBSERVER_ENABLED; // reserve last temporary for observers if enabled
120
121		free_alloca(vars_map, use_heap2);
122	4.34k	}

Coverage Report

Created: 2026-09-14 06:25