Coverage Report

Created: 2025-06-13 06:43

/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
}