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

Source
/*
   +----------------------------------------------------------------------+
   | Zend Engine, Removing unused variables                               |
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | 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++) {
    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 (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: Nikita Popov <nikic@php.net> \|
16		+----------------------------------------------------------------------+
17		*/
18
19		#include "Optimizer/zend_optimizer_internal.h"
20		#include "zend_bitset.h"
21		#include "zend_observer.h"
22
23		/* This pass removes all CVs and temporaries that are completely unused. It does not merge any CVs or TMPs.
24		* This pass does not operate on SSA form anymore. */
25	82	void zend_optimizer_compact_vars(zend_op_array *op_array) {
26	82	int i;
27
28	82	ALLOCA_FLAG(use_heap1);
29	82	ALLOCA_FLAG(use_heap2);
30	82	uint32_t used_vars_len = zend_bitset_len(op_array->last_var + op_array->T);
31	82	zend_bitset used_vars = ZEND_BITSET_ALLOCA(used_vars_len, use_heap1);
32	82	uint32_t vars_map = do_alloca((op_array->last_var + op_array->T) sizeof(uint32_t), use_heap2);
33	82	uint32_t num_cvs, num_tmps;
34
35		/* Determine which CVs are used */
36	82	zend_bitset_clear(used_vars, used_vars_len);
37	5.78k	for (i = 0; i < op_array->last; i++) {
38	5.69k	zend_op *opline = &op_array->opcodes[i];
39	5.69k	if (opline->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
40	4.32k	zend_bitset_incl(used_vars, VAR_NUM(opline->op1.var));
41	4.32k	}
42	5.69k	if (opline->op2_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
43	1.64k	zend_bitset_incl(used_vars, VAR_NUM(opline->op2.var));
44	1.64k	}
45	5.69k	if (opline->result_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
46	3.98k	zend_bitset_incl(used_vars, VAR_NUM(opline->result.var));
47	3.98k	if (opline->opcode == ZEND_ROPE_INIT) {
48	36	uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval);
49	1.14k	while (num > 1) {
50	1.10k	num--;
51	1.10k	zend_bitset_incl(used_vars, VAR_NUM(opline->result.var) + num);
52	1.10k	}
53	36	}
54	3.98k	}
55	5.69k	}
56
57	82	num_cvs = 0;
58	685	for (i = 0; i < op_array->last_var; i++) {
59	603	if (zend_bitset_in(used_vars, i)) {
60	596	vars_map[i] = num_cvs++;
61	596	} else {
62	7	vars_map[i] = (uint32_t) -1;
63	7	}
64	603	}
65
66	82	num_tmps = 0;
67	1.07k	for (i = op_array->last_var; i < op_array->last_var + op_array->T; i++) {
68	989	if (zend_bitset_in(used_vars, i)) {
69	989	vars_map[i] = num_cvs + num_tmps++;
70	989	} else {
71	0	vars_map[i] = (uint32_t) -1;
72	0	}
73	989	}
74
75	82	free_alloca(used_vars, use_heap1);
76	82	if (num_cvs == op_array->last_var && num_tmps == op_array->T) {
77	78	free_alloca(vars_map, use_heap2);
78	78	return;
79	78	}
80
81	4	ZEND_ASSERT(num_cvs <= op_array->last_var);
82	4	ZEND_ASSERT(num_tmps <= op_array->T);
83
84		/* Update CV and TMP references in opcodes */
85	477	for (i = 0; i < op_array->last; i++) {
86	473	zend_op *opline = &op_array->opcodes[i];
87	473	if (opline->op1_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
88	314	opline->op1.var = NUM_VAR(vars_map[VAR_NUM(opline->op1.var)]);
89	314	}
90	473	if (opline->op2_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
91	86	opline->op2.var = NUM_VAR(vars_map[VAR_NUM(opline->op2.var)]);
92	86	}
93	473	if (opline->result_type & (IS_CV\|IS_VAR\|IS_TMP_VAR)) {
94	171	opline->result.var = NUM_VAR(vars_map[VAR_NUM(opline->result.var)]);
95	171	}
96	473	}
97
98		/* Update CV name table */
99	4	if (num_cvs != op_array->last_var) {
100	4	if (num_cvs) {
101	4	zend_string *names = safe_emalloc(sizeof(zend_string ), num_cvs, 0);
102	40	for (i = 0; i < op_array->last_var; i++) {
103	36	if (vars_map[i] != (uint32_t) -1) {
104	29	names[vars_map[i]] = op_array->vars[i];
105	29	} else {
106	7	zend_string_release_ex(op_array->vars[i], 0);
107	7	}
108	36	}
109	4	efree(op_array->vars);
110	4	op_array->vars = names;
111	4	} else {
112	0	for (i = 0; i < op_array->last_var; i++) {
113	0	zend_string_release_ex(op_array->vars[i], 0);
114	0	}
115	0	efree(op_array->vars);
116	0	op_array->vars = NULL;
117	0	}
118	4	op_array->last_var = num_cvs;
119	4	}
120
121	4	op_array->T = num_tmps + ZEND_OBSERVER_ENABLED; // reserve last temporary for observers if enabled
122
123		free_alloca(vars_map, use_heap2);
124	4	}

Coverage Report

Created: 2026-01-18 06:48