/src/php-src/Zend/Optimizer/compact_literals.c
Line | Count | Source (jump to first uncovered line) |
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: Dmitry Stogov <dmitry@php.net> | |
16 | | | Xinchen Hui <laruence@php.net> | |
17 | | +----------------------------------------------------------------------+ |
18 | | */ |
19 | | |
20 | | /* pass 11 |
21 | | * - compact literals table |
22 | | */ |
23 | | |
24 | | #include "Optimizer/zend_optimizer.h" |
25 | | #include "Optimizer/zend_optimizer_internal.h" |
26 | | #include "zend_API.h" |
27 | | #include "zend_constants.h" |
28 | | #include "zend_execute.h" |
29 | | #include "zend_vm.h" |
30 | | #include "zend_extensions.h" |
31 | | |
32 | | #define DEBUG_COMPACT_LITERALS 0 |
33 | | |
34 | 2.48k | #define LITERAL_CLASS_CONST 1 |
35 | 4.59k | #define LITERAL_STATIC_METHOD 2 |
36 | 10.5k | #define LITERAL_STATIC_PROPERTY 3 |
37 | | |
38 | | typedef struct _literal_info { |
39 | | uint8_t num_related; |
40 | | } literal_info; |
41 | | |
42 | 1.15M | #define LITERAL_INFO(n, related) do { \ |
43 | 1.15M | info[n].num_related = (related); \ |
44 | 1.15M | } while (0) |
45 | | |
46 | | static uint32_t add_static_slot(HashTable *hash, |
47 | | zend_op_array *op_array, |
48 | | uint32_t op1, |
49 | | uint32_t op2, |
50 | | uint32_t kind, |
51 | | uint32_t *cache_size) |
52 | 10.4k | { |
53 | 10.4k | uint32_t ret; |
54 | 10.4k | zval *class_name = &op_array->literals[op1]; |
55 | 10.4k | zval *prop_name = &op_array->literals[op2]; |
56 | 10.4k | zval *pos, tmp; |
57 | | |
58 | 10.4k | zend_string *key = zend_create_member_string(Z_STR_P(class_name), Z_STR_P(prop_name)); |
59 | 10.4k | ZSTR_H(key) = zend_string_hash_func(key); |
60 | 10.4k | ZSTR_H(key) += kind; |
61 | | |
62 | 10.4k | pos = zend_hash_find(hash, key); |
63 | 10.4k | if (pos) { |
64 | 3.32k | ret = Z_LVAL_P(pos); |
65 | 7.14k | } else { |
66 | 7.14k | ret = *cache_size; |
67 | 7.14k | *cache_size += (kind == LITERAL_STATIC_PROPERTY ? 3 : 2) * sizeof(void *); |
68 | 7.14k | ZVAL_LONG(&tmp, ret); |
69 | 7.14k | zend_hash_add(hash, key, &tmp); |
70 | 7.14k | } |
71 | 10.4k | zend_string_release_ex(key, 0); |
72 | 10.4k | return ret; |
73 | 10.4k | } |
74 | | |
75 | | static inline void bias_key(zend_string *key, uint32_t bias) |
76 | 227k | { |
77 | | /* Add a bias to the hash so we can distinguish string keys |
78 | | * that would otherwise be the same. */ |
79 | 227k | ZSTR_H(key) = zend_string_hash_val(key) + bias; |
80 | 227k | } |
81 | | |
82 | | static zend_string *create_str_cache_key(zval *literal, uint8_t num_related) |
83 | 903k | { |
84 | 903k | ZEND_ASSERT(Z_TYPE_P(literal) == IS_STRING); |
85 | 903k | if (num_related == 1) { |
86 | 685k | return zend_string_copy(Z_STR_P(literal)); |
87 | 685k | } |
88 | | |
89 | | /* Concatenate all the related literals for the cache key. */ |
90 | 218k | zend_string *key; |
91 | 218k | if (num_related == 2) { |
92 | 214k | ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING); |
93 | 214k | key = zend_string_concat2( |
94 | 214k | Z_STRVAL_P(literal), Z_STRLEN_P(literal), |
95 | 214k | Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1)); |
96 | 214k | } else if (num_related == 3) { |
97 | 3.39k | ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING); |
98 | 3.39k | key = zend_string_concat3( |
99 | 3.39k | Z_STRVAL_P(literal), Z_STRLEN_P(literal), |
100 | 3.39k | Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1), |
101 | 3.39k | Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2)); |
102 | 3.39k | } else { |
103 | 0 | ZEND_ASSERT(0 && "Currently not needed"); |
104 | 0 | } |
105 | | |
106 | 218k | bias_key(key, num_related - 1); |
107 | 218k | return key; |
108 | 218k | } |
109 | | |
110 | | void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx *ctx) |
111 | 109k | { |
112 | 109k | zend_op *opline, *end; |
113 | 109k | int i, j, n, *map; |
114 | 109k | uint32_t cache_size; |
115 | 109k | zval zv, *pos; |
116 | 109k | literal_info *info; |
117 | 109k | int l_null = -1; |
118 | 109k | int l_false = -1; |
119 | 109k | int l_true = -1; |
120 | 109k | int l_empty_arr = -1; |
121 | 109k | HashTable hash; |
122 | 109k | zend_string *key = NULL; |
123 | 109k | void *checkpoint = zend_arena_checkpoint(ctx->arena); |
124 | 109k | int *const_slot, *class_slot, *func_slot, *bind_var_slot, *property_slot, *method_slot, *jmp_slot; |
125 | | |
126 | 109k | if (op_array->last_literal) { |
127 | 109k | info = (literal_info*)zend_arena_calloc(&ctx->arena, op_array->last_literal, sizeof(literal_info)); |
128 | | |
129 | | /* Mark literals of specific types */ |
130 | 109k | opline = op_array->opcodes; |
131 | 109k | end = opline + op_array->last; |
132 | 2.61M | while (opline < end) { |
133 | 2.50M | switch (opline->opcode) { |
134 | 0 | case ZEND_JMP_FRAMELESS: |
135 | 0 | LITERAL_INFO(opline->op1.constant, 1); |
136 | 0 | break; |
137 | 4.51k | case ZEND_INIT_FCALL_BY_NAME: |
138 | 4.51k | LITERAL_INFO(opline->op2.constant, 2); |
139 | 4.51k | break; |
140 | 2.52k | case ZEND_INIT_NS_FCALL_BY_NAME: |
141 | 2.52k | LITERAL_INFO(opline->op2.constant, 3); |
142 | 2.52k | break; |
143 | 44.5k | case ZEND_INIT_METHOD_CALL: |
144 | 44.5k | if (opline->op1_type == IS_CONST) { |
145 | 226 | LITERAL_INFO(opline->op1.constant, 1); |
146 | 226 | } |
147 | 44.5k | if (opline->op2_type == IS_CONST) { |
148 | 44.3k | LITERAL_INFO(opline->op2.constant, 2); |
149 | 44.3k | } |
150 | 44.5k | break; |
151 | 5.66k | case ZEND_INIT_STATIC_METHOD_CALL: |
152 | 5.66k | if (opline->op1_type == IS_CONST) { |
153 | 4.68k | LITERAL_INFO(opline->op1.constant, 2); |
154 | 4.68k | } |
155 | 5.66k | if (opline->op2_type == IS_CONST) { |
156 | 5.23k | LITERAL_INFO(opline->op2.constant, 2); |
157 | 5.23k | } |
158 | 5.66k | break; |
159 | 176 | case ZEND_INIT_PARENT_PROPERTY_HOOK_CALL: |
160 | 176 | LITERAL_INFO(opline->op1.constant, 1); |
161 | 176 | break; |
162 | 44.0k | case ZEND_CATCH: |
163 | 44.0k | LITERAL_INFO(opline->op1.constant, 2); |
164 | 44.0k | break; |
165 | 30.5k | case ZEND_FETCH_CONSTANT: |
166 | 30.5k | if (opline->op1.num & IS_CONSTANT_UNQUALIFIED_IN_NAMESPACE) { |
167 | 868 | LITERAL_INFO(opline->op2.constant, 3); |
168 | 29.6k | } else { |
169 | 29.6k | LITERAL_INFO(opline->op2.constant, 2); |
170 | 29.6k | } |
171 | 30.5k | break; |
172 | 3.14k | case ZEND_FETCH_CLASS_CONSTANT: |
173 | 3.14k | if (opline->op1_type == IS_CONST) { |
174 | 2.51k | LITERAL_INFO(opline->op1.constant, 2); |
175 | 2.51k | } |
176 | 3.14k | if (opline->op2_type == IS_CONST) { |
177 | 3.09k | LITERAL_INFO(opline->op2.constant, 1); |
178 | 3.09k | } |
179 | 3.14k | break; |
180 | 1.16k | case ZEND_ASSIGN_STATIC_PROP: |
181 | 1.43k | case ZEND_ASSIGN_STATIC_PROP_REF: |
182 | 3.62k | case ZEND_FETCH_STATIC_PROP_R: |
183 | 3.97k | case ZEND_FETCH_STATIC_PROP_W: |
184 | 3.97k | case ZEND_FETCH_STATIC_PROP_RW: |
185 | 4.17k | case ZEND_FETCH_STATIC_PROP_IS: |
186 | 4.21k | case ZEND_FETCH_STATIC_PROP_UNSET: |
187 | 4.49k | case ZEND_FETCH_STATIC_PROP_FUNC_ARG: |
188 | 4.50k | case ZEND_UNSET_STATIC_PROP: |
189 | 4.61k | case ZEND_ISSET_ISEMPTY_STATIC_PROP: |
190 | 4.66k | case ZEND_PRE_INC_STATIC_PROP: |
191 | 4.66k | case ZEND_PRE_DEC_STATIC_PROP: |
192 | 4.73k | case ZEND_POST_INC_STATIC_PROP: |
193 | 4.75k | case ZEND_POST_DEC_STATIC_PROP: |
194 | 4.84k | case ZEND_ASSIGN_STATIC_PROP_OP: |
195 | 4.84k | if (opline->op2_type == IS_CONST) { |
196 | 3.66k | LITERAL_INFO(opline->op2.constant, 2); |
197 | 3.66k | } |
198 | 4.84k | if (opline->op1_type == IS_CONST) { |
199 | 4.53k | LITERAL_INFO(opline->op1.constant, 1); |
200 | 4.53k | } |
201 | 4.84k | break; |
202 | 1.33k | case ZEND_FETCH_CLASS: |
203 | 1.72k | case ZEND_INSTANCEOF: |
204 | 1.72k | if (opline->op2_type == IS_CONST) { |
205 | 347 | LITERAL_INFO(opline->op2.constant, 2); |
206 | 347 | } |
207 | 1.72k | break; |
208 | 70.8k | case ZEND_NEW: |
209 | 70.8k | if (opline->op1_type == IS_CONST) { |
210 | 69.6k | LITERAL_INFO(opline->op1.constant, 2); |
211 | 69.6k | } |
212 | 70.8k | break; |
213 | 4.76k | case ZEND_DECLARE_CLASS: |
214 | 6.14k | case ZEND_DECLARE_CLASS_DELAYED: |
215 | 6.14k | LITERAL_INFO(opline->op1.constant, 2); |
216 | 6.14k | if (opline->op2_type == IS_CONST) { |
217 | 2.02k | LITERAL_INFO(opline->op2.constant, 1); |
218 | 2.02k | } |
219 | 6.14k | break; |
220 | 2.29k | case ZEND_ISSET_ISEMPTY_DIM_OBJ: |
221 | 11.2k | case ZEND_ASSIGN_DIM: |
222 | 12.2k | case ZEND_UNSET_DIM: |
223 | 20.5k | case ZEND_FETCH_DIM_R: |
224 | 23.0k | case ZEND_FETCH_DIM_W: |
225 | 24.0k | case ZEND_FETCH_DIM_RW: |
226 | 25.0k | case ZEND_FETCH_DIM_IS: |
227 | 25.8k | case ZEND_FETCH_DIM_FUNC_ARG: |
228 | 26.0k | case ZEND_FETCH_DIM_UNSET: |
229 | 27.2k | case ZEND_FETCH_LIST_R: |
230 | 27.5k | case ZEND_FETCH_LIST_W: |
231 | 28.9k | case ZEND_ASSIGN_DIM_OP: |
232 | 28.9k | if (opline->op1_type == IS_CONST) { |
233 | 355 | LITERAL_INFO(opline->op1.constant, 1); |
234 | 355 | } |
235 | 28.9k | if (opline->op2_type == IS_CONST) { |
236 | 16.8k | if (Z_EXTRA(op_array->literals[opline->op2.constant]) == ZEND_EXTRA_VALUE) { |
237 | 512 | LITERAL_INFO(opline->op2.constant, 2); |
238 | 16.3k | } else { |
239 | 16.3k | LITERAL_INFO(opline->op2.constant, 1); |
240 | 16.3k | } |
241 | 16.8k | } |
242 | 28.9k | break; |
243 | 2.25M | default: |
244 | 2.25M | if (opline->op1_type == IS_CONST) { |
245 | 357k | LITERAL_INFO(opline->op1.constant, 1); |
246 | 357k | } |
247 | 2.25M | if (opline->op2_type == IS_CONST) { |
248 | 554k | LITERAL_INFO(opline->op2.constant, 1); |
249 | 554k | } |
250 | 2.25M | break; |
251 | 2.50M | } |
252 | 2.50M | opline++; |
253 | 2.50M | } |
254 | | |
255 | | #if DEBUG_COMPACT_LITERALS |
256 | | { |
257 | | fprintf(stderr, "File %s func %s\n", op_array->filename->val, |
258 | | op_array->function_name ? op_array->function_name->val : "main"); |
259 | | fprintf(stderr, "Literals table size %d\n", op_array->last_literal); |
260 | | |
261 | | for (int i = 0; i < op_array->last_literal; i++) { |
262 | | zend_string *str = zval_get_string(op_array->literals + i); |
263 | | fprintf(stderr, "Literal %d, val (%zu):%s\n", i, ZSTR_LEN(str), ZSTR_VAL(str)); |
264 | | zend_string_release(str); |
265 | | } |
266 | | fflush(stderr); |
267 | | } |
268 | | #endif |
269 | | |
270 | | /* Merge equal constants */ |
271 | 109k | j = 0; |
272 | 109k | zend_hash_init(&hash, op_array->last_literal, NULL, NULL, 0); |
273 | 109k | map = (int*)zend_arena_alloc(&ctx->arena, op_array->last_literal * sizeof(int)); |
274 | 109k | memset(map, 0, op_array->last_literal * sizeof(int)); |
275 | 1.30M | for (i = 0; i < op_array->last_literal; i++) { |
276 | 1.19M | if (!info[i].num_related) { |
277 | | /* unset literal */ |
278 | 42.2k | zval_ptr_dtor_nogc(&op_array->literals[i]); |
279 | 42.2k | continue; |
280 | 42.2k | } |
281 | 1.15M | switch (Z_TYPE(op_array->literals[i])) { |
282 | 36.7k | case IS_NULL: |
283 | 36.7k | ZEND_ASSERT(info[i].num_related == 1); |
284 | 36.7k | if (l_null < 0) { |
285 | 31.4k | l_null = j; |
286 | 31.4k | if (i != j) { |
287 | 8.43k | op_array->literals[j] = op_array->literals[i]; |
288 | 8.43k | info[j] = info[i]; |
289 | 8.43k | } |
290 | 31.4k | j++; |
291 | 31.4k | } |
292 | 36.7k | map[i] = l_null; |
293 | 36.7k | break; |
294 | 2.80k | case IS_FALSE: |
295 | 2.80k | ZEND_ASSERT(info[i].num_related == 1); |
296 | 2.80k | if (l_false < 0) { |
297 | 1.83k | l_false = j; |
298 | 1.83k | if (i != j) { |
299 | 776 | op_array->literals[j] = op_array->literals[i]; |
300 | 776 | info[j] = info[i]; |
301 | 776 | } |
302 | 1.83k | j++; |
303 | 1.83k | } |
304 | 2.80k | map[i] = l_false; |
305 | 2.80k | break; |
306 | 3.21k | case IS_TRUE: |
307 | 3.21k | ZEND_ASSERT(info[i].num_related == 1); |
308 | 3.21k | if (l_true < 0) { |
309 | 2.04k | l_true = j; |
310 | 2.04k | if (i != j) { |
311 | 761 | op_array->literals[j] = op_array->literals[i]; |
312 | 761 | info[j] = info[i]; |
313 | 761 | } |
314 | 2.04k | j++; |
315 | 2.04k | } |
316 | 3.21k | map[i] = l_true; |
317 | 3.21k | break; |
318 | 180k | case IS_LONG: |
319 | 180k | if (info[i].num_related == 1) { |
320 | 179k | if ((pos = zend_hash_index_find(&hash, Z_LVAL(op_array->literals[i]))) != NULL) { |
321 | 54.7k | map[i] = Z_LVAL_P(pos); |
322 | 124k | } else { |
323 | 124k | map[i] = j; |
324 | 124k | ZVAL_LONG(&zv, j); |
325 | 124k | zend_hash_index_add_new(&hash, Z_LVAL(op_array->literals[i]), &zv); |
326 | 124k | if (i != j) { |
327 | 43.0k | op_array->literals[j] = op_array->literals[i]; |
328 | 43.0k | info[j] = info[i]; |
329 | 43.0k | } |
330 | 124k | j++; |
331 | 124k | } |
332 | 179k | } else { |
333 | 512 | ZEND_ASSERT(info[i].num_related == 2); |
334 | 512 | key = zend_string_init(Z_STRVAL(op_array->literals[i+1]), Z_STRLEN(op_array->literals[i+1]), 0); |
335 | 512 | bias_key(key, 100 + info[i].num_related - 1); |
336 | 512 | if ((pos = zend_hash_find(&hash, key)) != NULL) { |
337 | 210 | ZEND_ASSERT(info[Z_LVAL_P(pos)].num_related == 2); |
338 | 210 | map[i] = Z_LVAL_P(pos); |
339 | 210 | zval_ptr_dtor_nogc(&op_array->literals[i+1]); |
340 | 302 | } else { |
341 | 302 | map[i] = j; |
342 | 302 | ZVAL_LONG(&zv, j); |
343 | 302 | zend_hash_add_new(&hash, key, &zv); |
344 | 302 | if (i != j) { |
345 | 224 | op_array->literals[j] = op_array->literals[i]; |
346 | 224 | info[j] = info[i]; |
347 | 224 | op_array->literals[j+1] = op_array->literals[i+1]; |
348 | 224 | info[j+1] = info[i+1]; |
349 | 224 | } |
350 | 302 | j += 2; |
351 | 302 | } |
352 | 512 | zend_string_release_ex(key, 0); |
353 | 512 | i++; |
354 | 512 | } |
355 | 180k | break; |
356 | 180k | case IS_DOUBLE: |
357 | 8.69k | ZEND_ASSERT(info[i].num_related == 1); |
358 | 8.69k | key = zend_string_init((char*)&Z_DVAL(op_array->literals[i]), sizeof(double), 0); |
359 | 8.69k | bias_key(key, 200); |
360 | 8.69k | if ((pos = zend_hash_find(&hash, key))) { |
361 | 1.54k | map[i] = Z_LVAL_P(pos); |
362 | 7.15k | } else { |
363 | 7.15k | map[i] = j; |
364 | 7.15k | ZVAL_LONG(&zv, j); |
365 | 7.15k | zend_hash_add_new(&hash, key, &zv); |
366 | 7.15k | if (i != j) { |
367 | 3.71k | op_array->literals[j] = op_array->literals[i]; |
368 | 3.71k | info[j] = info[i]; |
369 | 3.71k | } |
370 | 7.15k | j++; |
371 | 7.15k | } |
372 | 8.69k | zend_string_release_ex(key, 0); |
373 | 8.69k | break; |
374 | 903k | case IS_STRING: { |
375 | 903k | key = create_str_cache_key(&op_array->literals[i], info[i].num_related); |
376 | 903k | if ((pos = zend_hash_find(&hash, key)) != NULL) { |
377 | 345k | ZEND_ASSERT(Z_TYPE(op_array->literals[Z_LVAL_P(pos)]) == IS_STRING && |
378 | 345k | info[i].num_related == info[Z_LVAL_P(pos)].num_related); |
379 | 345k | zend_string_release_ex(key, 0); |
380 | 345k | map[i] = Z_LVAL_P(pos); |
381 | 345k | zval_ptr_dtor_nogc(&op_array->literals[i]); |
382 | 345k | n = info[i].num_related; |
383 | 410k | while (n > 1) { |
384 | 65.7k | i++; |
385 | 65.7k | zval_ptr_dtor_nogc(&op_array->literals[i]); |
386 | 65.7k | n--; |
387 | 65.7k | } |
388 | 558k | } else { |
389 | 558k | map[i] = j; |
390 | 558k | ZVAL_LONG(&zv, j); |
391 | 558k | zend_hash_add_new(&hash, key, &zv); |
392 | 558k | zend_string_release_ex(key, 0); |
393 | 558k | if (i != j) { |
394 | 151k | op_array->literals[j] = op_array->literals[i]; |
395 | 151k | info[j] = info[i]; |
396 | 151k | } |
397 | 558k | j++; |
398 | 558k | n = info[i].num_related; |
399 | 714k | while (n > 1) { |
400 | 155k | i++; |
401 | 155k | if (i != j) op_array->literals[j] = op_array->literals[i]; |
402 | 155k | j++; |
403 | 155k | n--; |
404 | 155k | } |
405 | 558k | } |
406 | 903k | break; |
407 | 903k | } |
408 | 903k | case IS_ARRAY: |
409 | 20.5k | ZEND_ASSERT(info[i].num_related == 1); |
410 | 20.5k | if (zend_hash_num_elements(Z_ARRVAL(op_array->literals[i])) == 0) { |
411 | 2.83k | if (l_empty_arr < 0) { |
412 | 2.35k | l_empty_arr = j; |
413 | 2.35k | if (i != j) { |
414 | 1.01k | op_array->literals[j] = op_array->literals[i]; |
415 | 1.01k | info[j] = info[i]; |
416 | 1.01k | } |
417 | 2.35k | j++; |
418 | 2.35k | } else { |
419 | 482 | zval_ptr_dtor_nogc(&op_array->literals[i]); |
420 | 482 | } |
421 | 2.83k | map[i] = l_empty_arr; |
422 | 2.83k | break; |
423 | 2.83k | } |
424 | 17.7k | ZEND_FALLTHROUGH; |
425 | 19.2k | default: |
426 | | /* don't merge other types */ |
427 | 19.2k | ZEND_ASSERT(info[i].num_related == 1); |
428 | 19.2k | map[i] = j; |
429 | 19.2k | if (i != j) { |
430 | 3.34k | op_array->literals[j] = op_array->literals[i]; |
431 | 3.34k | info[j] = info[i]; |
432 | 3.34k | } |
433 | 19.2k | j++; |
434 | 19.2k | break; |
435 | 1.15M | } |
436 | 1.15M | } |
437 | | |
438 | | /* Only clean "hash", as it will be reused in the loop below. */ |
439 | 109k | zend_hash_clean(&hash); |
440 | 109k | op_array->last_literal = j; |
441 | | |
442 | 109k | const_slot = zend_arena_alloc(&ctx->arena, j * 7 * sizeof(int)); |
443 | 109k | memset(const_slot, -1, j * 7 * sizeof(int)); |
444 | 109k | class_slot = const_slot + j; |
445 | 109k | func_slot = class_slot + j; |
446 | 109k | bind_var_slot = func_slot + j; |
447 | 109k | property_slot = bind_var_slot + j; |
448 | 109k | method_slot = property_slot + j; |
449 | 109k | jmp_slot = method_slot + j; |
450 | | |
451 | | /* Update opcodes to use new literals table */ |
452 | 109k | cache_size = zend_op_array_extension_handles * sizeof(void*); |
453 | 109k | opline = op_array->opcodes; |
454 | 109k | end = opline + op_array->last; |
455 | 2.61M | while (opline < end) { |
456 | 2.50M | if (opline->op1_type == IS_CONST) { |
457 | 490k | opline->op1.constant = map[opline->op1.constant]; |
458 | 490k | } |
459 | 2.50M | if (opline->op2_type == IS_CONST) { |
460 | 667k | opline->op2.constant = map[opline->op2.constant]; |
461 | 667k | } |
462 | 2.50M | switch (opline->opcode) { |
463 | 86 | case ZEND_ASSIGN_STATIC_PROP_OP: |
464 | 86 | if (opline->op1_type == IS_CONST) { |
465 | | // op1 static property |
466 | 86 | if (opline->op2_type == IS_CONST) { |
467 | 86 | (opline+1)->extended_value = add_static_slot(&hash, op_array, |
468 | 86 | opline->op2.constant, |
469 | 86 | opline->op1.constant, |
470 | 86 | LITERAL_STATIC_PROPERTY, |
471 | 86 | &cache_size); |
472 | 86 | } else { |
473 | 0 | (opline+1)->extended_value = cache_size; |
474 | 0 | cache_size += 3 * sizeof(void *); |
475 | 0 | } |
476 | 86 | } else if (opline->op2_type == IS_CONST) { |
477 | | // op2 class |
478 | 0 | if (class_slot[opline->op2.constant] >= 0) { |
479 | 0 | (opline+1)->extended_value = class_slot[opline->op2.constant]; |
480 | 0 | } else { |
481 | 0 | (opline+1)->extended_value = cache_size; |
482 | 0 | class_slot[opline->op2.constant] = cache_size; |
483 | 0 | cache_size += sizeof(void *); |
484 | 0 | } |
485 | 0 | } |
486 | 86 | break; |
487 | 644 | case ZEND_ASSIGN_OBJ_OP: |
488 | 644 | if (opline->op2_type == IS_CONST) { |
489 | | // op2 property |
490 | 550 | if (opline->op1_type == IS_UNUSED && |
491 | 550 | property_slot[opline->op2.constant] >= 0) { |
492 | 46 | (opline+1)->extended_value = property_slot[opline->op2.constant]; |
493 | 504 | } else { |
494 | 504 | (opline+1)->extended_value = cache_size; |
495 | 504 | cache_size += 3 * sizeof(void *); |
496 | 504 | if (opline->op1_type == IS_UNUSED) { |
497 | 64 | property_slot[opline->op2.constant] = (opline+1)->extended_value; |
498 | 64 | } |
499 | 504 | } |
500 | 550 | } |
501 | 644 | break; |
502 | 9.20k | case ZEND_ASSIGN_OBJ: |
503 | 9.77k | case ZEND_ASSIGN_OBJ_REF: |
504 | 81.3k | case ZEND_FETCH_OBJ_R: |
505 | 83.8k | case ZEND_FETCH_OBJ_W: |
506 | 83.8k | case ZEND_FETCH_OBJ_RW: |
507 | 84.6k | case ZEND_FETCH_OBJ_IS: |
508 | 84.8k | case ZEND_FETCH_OBJ_UNSET: |
509 | 85.4k | case ZEND_FETCH_OBJ_FUNC_ARG: |
510 | 86.3k | case ZEND_UNSET_OBJ: |
511 | 87.0k | case ZEND_PRE_INC_OBJ: |
512 | 87.4k | case ZEND_PRE_DEC_OBJ: |
513 | 87.7k | case ZEND_POST_INC_OBJ: |
514 | 87.8k | case ZEND_POST_DEC_OBJ: |
515 | 87.8k | if (opline->op2_type == IS_CONST) { |
516 | | // op2 property |
517 | 86.3k | if (opline->op1_type == IS_UNUSED && |
518 | 86.3k | property_slot[opline->op2.constant] >= 0) { |
519 | 1.01k | opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
520 | 85.3k | } else { |
521 | 85.3k | opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
522 | 85.3k | cache_size += 3 * sizeof(void *); |
523 | 85.3k | if (opline->op1_type == IS_UNUSED) { |
524 | 5.98k | property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS; |
525 | 5.98k | } |
526 | 85.3k | } |
527 | 86.3k | } |
528 | 87.8k | break; |
529 | 631 | case ZEND_ISSET_ISEMPTY_PROP_OBJ: |
530 | 631 | if (opline->op2_type == IS_CONST) { |
531 | | // op2 property |
532 | 569 | if (opline->op1_type == IS_UNUSED && |
533 | 569 | property_slot[opline->op2.constant] >= 0) { |
534 | 12 | opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_ISEMPTY); |
535 | 557 | } else { |
536 | 557 | opline->extended_value = cache_size | (opline->extended_value & ZEND_ISEMPTY); |
537 | 557 | cache_size += 3 * sizeof(void *); |
538 | 557 | if (opline->op1_type == IS_UNUSED) { |
539 | 36 | property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_ISEMPTY; |
540 | 36 | } |
541 | 557 | } |
542 | 569 | } |
543 | 631 | break; |
544 | 110k | case ZEND_INIT_FCALL: |
545 | 115k | case ZEND_INIT_FCALL_BY_NAME: |
546 | 117k | case ZEND_INIT_NS_FCALL_BY_NAME: |
547 | | // op2 func |
548 | 117k | if (func_slot[opline->op2.constant] >= 0) { |
549 | 50.7k | opline->result.num = func_slot[opline->op2.constant]; |
550 | 66.7k | } else { |
551 | 66.7k | opline->result.num = cache_size; |
552 | 66.7k | cache_size += sizeof(void *); |
553 | 66.7k | func_slot[opline->op2.constant] = opline->result.num; |
554 | 66.7k | } |
555 | 117k | break; |
556 | 44.5k | case ZEND_INIT_METHOD_CALL: |
557 | 44.5k | if (opline->op2_type == IS_CONST) { |
558 | | // op2 method |
559 | 44.3k | if (opline->op1_type == IS_UNUSED && |
560 | 44.3k | method_slot[opline->op2.constant] >= 0) { |
561 | 0 | opline->result.num = method_slot[opline->op2.constant]; |
562 | 44.3k | } else { |
563 | 44.3k | opline->result.num = cache_size; |
564 | 44.3k | cache_size += 2 * sizeof(void *); |
565 | 44.3k | if (opline->op1_type == IS_UNUSED) { |
566 | 553 | method_slot[opline->op2.constant] = opline->result.num; |
567 | 553 | } |
568 | 44.3k | } |
569 | 44.3k | } |
570 | 44.5k | break; |
571 | 5.66k | case ZEND_INIT_STATIC_METHOD_CALL: |
572 | 5.66k | if (opline->op2_type == IS_CONST) { |
573 | | // op2 static method |
574 | 5.23k | if (opline->op1_type == IS_CONST) { |
575 | 4.59k | opline->result.num = add_static_slot(&hash, op_array, |
576 | 4.59k | opline->op1.constant, |
577 | 4.59k | opline->op2.constant, |
578 | 4.59k | LITERAL_STATIC_METHOD, |
579 | 4.59k | &cache_size); |
580 | 4.59k | } else { |
581 | 640 | opline->result.num = cache_size; |
582 | 640 | cache_size += 2 * sizeof(void *); |
583 | 640 | } |
584 | 5.23k | } else if (opline->op1_type == IS_CONST) { |
585 | | // op1 class |
586 | 93 | if (class_slot[opline->op1.constant] >= 0) { |
587 | 37 | opline->result.num = class_slot[opline->op1.constant]; |
588 | 56 | } else { |
589 | 56 | opline->result.num = cache_size; |
590 | 56 | cache_size += sizeof(void *); |
591 | 56 | class_slot[opline->op1.constant] = opline->result.num; |
592 | 56 | } |
593 | 93 | } |
594 | 5.66k | break; |
595 | 77 | case ZEND_DEFINED: |
596 | | // op1 const |
597 | 77 | if (const_slot[opline->op1.constant] >= 0) { |
598 | 33 | opline->extended_value = const_slot[opline->op1.constant]; |
599 | 44 | } else { |
600 | 44 | opline->extended_value = cache_size; |
601 | 44 | cache_size += sizeof(void *); |
602 | 44 | const_slot[opline->op1.constant] = opline->extended_value; |
603 | 44 | } |
604 | 77 | break; |
605 | 30.5k | case ZEND_FETCH_CONSTANT: |
606 | | // op2 const |
607 | 30.5k | if (const_slot[opline->op2.constant] >= 0) { |
608 | 16.3k | opline->extended_value = const_slot[opline->op2.constant]; |
609 | 16.3k | } else { |
610 | 14.1k | opline->extended_value = cache_size; |
611 | 14.1k | cache_size += sizeof(void *); |
612 | 14.1k | const_slot[opline->op2.constant] = opline->extended_value; |
613 | 14.1k | } |
614 | 30.5k | break; |
615 | 3.14k | case ZEND_FETCH_CLASS_CONSTANT: |
616 | 3.14k | if (opline->op1_type == IS_CONST |
617 | 3.14k | && opline->op2_type == IS_CONST |
618 | 3.14k | && Z_TYPE(op_array->literals[opline->op2.constant]) == IS_STRING) { |
619 | | // op1/op2 class_const |
620 | 2.48k | opline->extended_value = add_static_slot(&hash, op_array, |
621 | 2.48k | opline->op1.constant, |
622 | 2.48k | opline->op2.constant, |
623 | 2.48k | LITERAL_CLASS_CONST, |
624 | 2.48k | &cache_size); |
625 | 2.48k | } else { |
626 | 659 | opline->extended_value = cache_size; |
627 | 659 | cache_size += 2 * sizeof(void *); |
628 | 659 | } |
629 | 3.14k | break; |
630 | 1.16k | case ZEND_ASSIGN_STATIC_PROP: |
631 | 1.43k | case ZEND_ASSIGN_STATIC_PROP_REF: |
632 | 3.62k | case ZEND_FETCH_STATIC_PROP_R: |
633 | 3.97k | case ZEND_FETCH_STATIC_PROP_W: |
634 | 3.97k | case ZEND_FETCH_STATIC_PROP_RW: |
635 | 4.17k | case ZEND_FETCH_STATIC_PROP_IS: |
636 | 4.21k | case ZEND_FETCH_STATIC_PROP_UNSET: |
637 | 4.49k | case ZEND_FETCH_STATIC_PROP_FUNC_ARG: |
638 | 4.50k | case ZEND_UNSET_STATIC_PROP: |
639 | 4.61k | case ZEND_ISSET_ISEMPTY_STATIC_PROP: |
640 | 4.66k | case ZEND_PRE_INC_STATIC_PROP: |
641 | 4.66k | case ZEND_PRE_DEC_STATIC_PROP: |
642 | 4.73k | case ZEND_POST_INC_STATIC_PROP: |
643 | 4.75k | case ZEND_POST_DEC_STATIC_PROP: |
644 | 4.75k | if (opline->op1_type == IS_CONST) { |
645 | | // op1 static property |
646 | 4.44k | if (opline->op2_type == IS_CONST) { |
647 | 3.29k | opline->extended_value = add_static_slot(&hash, op_array, |
648 | 3.29k | opline->op2.constant, |
649 | 3.29k | opline->op1.constant, |
650 | 3.29k | LITERAL_STATIC_PROPERTY, |
651 | 3.29k | &cache_size) | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
652 | 3.29k | } else { |
653 | 1.15k | opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
654 | 1.15k | cache_size += 3 * sizeof(void *); |
655 | 1.15k | } |
656 | 4.44k | } else if (opline->op2_type == IS_CONST) { |
657 | | // op2 class |
658 | 282 | if (class_slot[opline->op2.constant] >= 0) { |
659 | 246 | opline->extended_value = class_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
660 | 246 | } else { |
661 | 36 | opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS); |
662 | 36 | class_slot[opline->op2.constant] = cache_size; |
663 | 36 | cache_size += sizeof(void *); |
664 | 36 | } |
665 | 282 | } |
666 | 4.75k | break; |
667 | 1.33k | case ZEND_FETCH_CLASS: |
668 | 1.72k | case ZEND_INSTANCEOF: |
669 | 1.72k | if (opline->op2_type == IS_CONST) { |
670 | | // op2 class |
671 | 347 | if (class_slot[opline->op2.constant] >= 0) { |
672 | 164 | opline->extended_value = class_slot[opline->op2.constant]; |
673 | 183 | } else { |
674 | 183 | opline->extended_value = cache_size; |
675 | 183 | cache_size += sizeof(void *); |
676 | 183 | class_slot[opline->op2.constant] = opline->extended_value; |
677 | 183 | } |
678 | 347 | } |
679 | 1.72k | break; |
680 | 70.8k | case ZEND_NEW: |
681 | 70.8k | if (opline->op1_type == IS_CONST) { |
682 | | // op1 class |
683 | 69.6k | if (class_slot[opline->op1.constant] >= 0) { |
684 | 11.4k | opline->op2.num = class_slot[opline->op1.constant]; |
685 | 58.1k | } else { |
686 | 58.1k | opline->op2.num = cache_size; |
687 | 58.1k | cache_size += sizeof(void *); |
688 | 58.1k | class_slot[opline->op1.constant] = opline->op2.num; |
689 | 58.1k | } |
690 | 69.6k | } |
691 | 70.8k | break; |
692 | 44.0k | case ZEND_CATCH: |
693 | 44.0k | if (opline->op1_type == IS_CONST) { |
694 | | // op1 class |
695 | 44.0k | if (class_slot[opline->op1.constant] >= 0) { |
696 | 7.01k | opline->extended_value = class_slot[opline->op1.constant] | (opline->extended_value & ZEND_LAST_CATCH); |
697 | 37.0k | } else { |
698 | 37.0k | opline->extended_value = cache_size | (opline->extended_value & ZEND_LAST_CATCH); |
699 | 37.0k | cache_size += sizeof(void *); |
700 | 37.0k | class_slot[opline->op1.constant] = opline->extended_value & ~ZEND_LAST_CATCH; |
701 | 37.0k | } |
702 | 44.0k | } |
703 | 44.0k | break; |
704 | 713 | case ZEND_BIND_GLOBAL: |
705 | | // op2 bind var |
706 | 713 | if (bind_var_slot[opline->op2.constant] >= 0) { |
707 | 18 | opline->extended_value = bind_var_slot[opline->op2.constant]; |
708 | 695 | } else { |
709 | 695 | opline->extended_value = cache_size; |
710 | 695 | cache_size += sizeof(void *); |
711 | 695 | bind_var_slot[opline->op2.constant] = opline->extended_value; |
712 | 695 | } |
713 | 713 | break; |
714 | 718 | case ZEND_DECLARE_ANON_CLASS: |
715 | 2.09k | case ZEND_DECLARE_CLASS_DELAYED: |
716 | 2.09k | opline->extended_value = cache_size; |
717 | 2.09k | cache_size += sizeof(void *); |
718 | 2.09k | break; |
719 | 0 | case ZEND_JMP_FRAMELESS: |
720 | | // op1 func |
721 | 0 | if (jmp_slot[opline->op1.constant] >= 0) { |
722 | 0 | opline->extended_value = jmp_slot[opline->op1.constant]; |
723 | 0 | } else { |
724 | 0 | opline->extended_value = cache_size; |
725 | 0 | cache_size += sizeof(void *); |
726 | 0 | jmp_slot[opline->op1.constant] = opline->extended_value; |
727 | 0 | } |
728 | 0 | break; |
729 | 70.9k | case ZEND_SEND_VAL: |
730 | 99.7k | case ZEND_SEND_VAL_EX: |
731 | 150k | case ZEND_SEND_VAR: |
732 | 226k | case ZEND_SEND_VAR_EX: |
733 | 227k | case ZEND_SEND_VAR_NO_REF: |
734 | 230k | case ZEND_SEND_VAR_NO_REF_EX: |
735 | 233k | case ZEND_SEND_REF: |
736 | 234k | case ZEND_SEND_FUNC_ARG: |
737 | 235k | case ZEND_CHECK_FUNC_ARG: |
738 | 235k | if (opline->op2_type == IS_CONST) { |
739 | 2.55k | opline->result.num = cache_size; |
740 | 2.55k | cache_size += 2 * sizeof(void *); |
741 | 2.55k | } |
742 | 235k | break; |
743 | 2.50M | } |
744 | 2.50M | opline++; |
745 | 2.50M | } |
746 | 109k | op_array->cache_size = cache_size; |
747 | 109k | zend_hash_destroy(&hash); |
748 | 109k | zend_arena_release(&ctx->arena, checkpoint); |
749 | | |
750 | 109k | if (1) { |
751 | 109k | opline = op_array->opcodes; |
752 | 133k | while (1) { |
753 | 133k | if (opline->opcode == ZEND_RECV_INIT) { |
754 | 2.81k | zval *val = &op_array->literals[opline->op2.constant]; |
755 | | |
756 | 2.81k | if (Z_TYPE_P(val) == IS_CONSTANT_AST) { |
757 | | /* Ensure zval is aligned to 8 bytes */ |
758 | 606 | op_array->cache_size = ZEND_MM_ALIGNED_SIZE_EX(op_array->cache_size, 8); |
759 | 606 | Z_CACHE_SLOT_P(val) = op_array->cache_size; |
760 | 606 | op_array->cache_size += sizeof(zval); |
761 | 606 | } |
762 | 130k | } else if (opline->opcode != ZEND_RECV) { |
763 | 109k | break; |
764 | 109k | } |
765 | 24.3k | opline++; |
766 | 24.3k | } |
767 | 109k | } |
768 | | |
769 | | #if DEBUG_COMPACT_LITERALS |
770 | | { |
771 | | fprintf(stderr, "Optimized literals table size %d\n", op_array->last_literal); |
772 | | |
773 | | for (int i = 0; i < op_array->last_literal; i++) { |
774 | | zend_string *str = zval_get_string(op_array->literals + i); |
775 | | fprintf(stderr, "Literal %d, val (%zu):%s\n", i, ZSTR_LEN(str), ZSTR_VAL(str)); |
776 | | zend_string_release(str); |
777 | | } |
778 | | fflush(stderr); |
779 | | } |
780 | | #endif |
781 | 109k | } |
782 | 109k | } |