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